Este artigo é a primeira parte da tradução e localização do whitepaper técnico oficial do Google Cloud sobre arquiteturas multiagente seguras.

Introdução

A construção de arquiteturas multiagente exige uma rigorosa defesa em profundidade, tratando cada LLM e cada ferramenta como um vetor potencial para diversas ameaças de segurança — incluindo, mas não se limitando, a prompt injection ou exfiltração de dados.

O Gemini Enterprise Agent Platform do Google Cloud oferece controles nativos de segurança em múltiplos níveis, contemplando recursos fundamentais projetados especificamente para sistemas baseados em agentes. Essas capacidades auxiliam as empresas a escalar o uso de IA e reduzir o tempo até a entrada em produção, ao mesmo tempo em que ampliam a postura de segurança.

Esta sequência de artigos descreve a aplicação prática desses controles por meio do detalhamento do processo de construção de um exemplo real: um sistema automatizado de solicitação de garantia (warranty claim system).

Jornada do usuário: Registrando uma solicitação em um sistema de garantia

(User journey: Filing a claim with a warranty claim system)

Imagine um cliente cujo eletrodoméstico inteligente de linha premium para de funcionar repentinamente. Frustrado, ele acessa o portal de suporte da sua empresa e preenche um formulário simples de texto livre: “Descreva o seu problema”. Em vez de navegar por menus suspensos complexos para categorizar a falha ou aguardar 48 horas pela resposta por e-mail de uma equipe de triagem, o usuário simplesmente digita o ocorrido e envia.

Em questão de segundos após o envio, o sistema de suporte impulsionado por IA lê a descrição, compreende o problema específico do aparelho e extrai o número de série fornecido. Nos bastidores — sem que o consumidor precise buscar comprovantes fiscais antigos ou aguardar um atendente humano consultar manualmente bases de dados — , o sistema verifica o status da garantia.

Com a garantia confirmada, o sistema rascunha de forma automática um pedido de substituição e emite uma etiqueta de remessa de devolução com uma transportadora premium. Para garantir a precisão e evitar fraudes automatizadas, essa etapa final de atendimento inclui uma breve retenção em fila interna para que um representante humano de suporte examine um resumo conciso, pré-validado, e clique em “Aprovar”.

Apenas alguns minutos após o envio do formulário, o cliente recebe um e-mail informando que a substituição está a caminho, transformando uma experiência frustrante de quebra de hardware em uma jornada de alta fidelização quase sem atritos.

Como essa experiência fluida realmente funciona nos bastidores? É aí que entra a arquitetura multiagente segura.

Visão geral da arquitetura: O Sistema de Solicitação de Garantia

(Architecture overview: The Warranty Claim System)

O Sistema de Solicitação de Garantia é construído sobre o Gemini Enterprise Agent Platform. Seu objetivo principal é automatizar o processamento de solicitações de garantia de clientes, incluindo o diagnóstico dos problemas relatados, a verificação dos produtos no histórico de compras e termos de garantia, e a execução das etapas de cumprimento logístico (fulfillment), como a emissão de etiquetas de postagem para peças de reposição.

O sistema multiagente estabelece uma fronteira rígida de segurança ao dividir as tarefas entre três personas de agentes:

Agente 1: Case Manager (Orquestrador)

• Ambiente de execução: Agent Runtime com Agent Identity.
• Propósito: Atua como o líder de diagnóstico, consumindo o gatilho inicial do Pub/Sub e categorizando a solicitação do cliente. Sua função primária é coordenar o fluxo de trabalho, iniciando chamadas seguras agent-to-agent (A2A) para subagentes especializados.
• Fronteira de segurança: Acesso estritamente negado a informações de identificação pessoal (PII) ou registros financeiros.

Agente 2: BigQuery Agent (com Data Vault)

• Ambiente de execução: Agent Runtime com Agent Identity.
• Propósito: Recebe entradas determinísticas e higienizadas (como números de série) para consultar termos de garantia em formato livre e retorna apenas um status simplificado (como “Covered”) para o Agente 1. O agente também consulta informações pessoais específicas (nome e endereço) necessárias para o Agente 3.
• Fronteira de segurança: Delega a execução a um servidor gerenciado de Model Context Protocol (MCP) do Google Cloud para o BigQuery. Este agente recebe permissões IAM exclusivas para consultar as tabelas de transações e garantias no BigQuery. Ele consulta unicamente os dados pessoais estritamente necessários para a entrega e é o único ponto de contato com o BigQuery em toda a arquitetura.

Agente 3: Logistics Liaison (Executor)

• Ambiente de execução: Cloud Run. A implantação do Logistics Liaison no Cloud Run demonstra a facilidade de integrar plataformas gerenciadas de IA com ambientes conteinerizados customizados. Vale ressaltar que esse agente poderia ser implantado diretamente no Agent Runtime (que suporta contêineres próprios — BYOC e operações de longa duração de até sete dias), mas este artigo demonstra propositalmente a integração entre Cloud Run e Agent Runtime.
• Propósito: Gerencia a fase de atendimento e cumprimento (fulfillment).
• Fronteira de segurança: O agente recebe acesso apenas aos dados pessoais específicos (nome e endereço) indispensáveis para a entrega, gerando etiquetas de remessa por meio de APIs externas habilitadas com MCP. Para mitigar riscos, conta com um gatilho de Human-in-the-Loop (HITL) que sinaliza automaticamente padrões anômalos para especialistas de fraude antes de qualquer ação externa ser disparada.

A arquitetura do Sistema de Solicitação de Garantia na Figura 1 descreve uma sequência de eventos que pode ser dividida em três fases. Cada fase descreve, em detalhes, os componentes da arquitetura.

Fase 1

Esta fase gerencia a interação inicial do usuário, garantindo que o prompt seja sanitizado pelo Model Armor antes de alcançar qualquer agente.

1 — Envio da solicitação (Claims submission): O cliente envia os dados através do Portal Web do Cliente (executado no Cloud Run), que publica o evento em um tópico de destino do Cloud Pub/Sub.

2 — Gatilho de evento (Event trigger): A assinatura do Pub/Sub aciona uma Cloud Run Function (o “Shim Session Manager”).

a. Inicialização da sessão (Session initialization): O Shim Session Manager recebe o payload raw e a envia ao Agent Gateway. O Agent Gateway estabelece uma sessão segura e prepara o roteamento do tráfego para o Gemini Enterprise Agent Platform Runtime (Agent Runtime).

3 — Sanitização de entrada (Input sanitization): Antes de rotear o prompt para o Case Manager, o Agent Gateway o submete ao Model Armor (integrado ao Sensitive Data Protection — SDP). O Model Armor realiza uma varredura de segurança em tempo real, filtrando tentativas de prompt injection, jailbreaks e mascaramento de informações pessoais (PII), passando apenas os dados da solicitação sanitizados para o agente Case Manager.

Fase 2

Nesta fase, o Case Manager delega a pesquisa de dados ao agente Data Vault. Com controles rigorosos de ingress configurados nos ambientes de execução, os agentes ficam impedidos de se comunicar peer-to-peer. Todo o tráfego lateral transita deliberadamente através do Agent Gateway. Os componentes arquitetônicos e a sequência de ações nesta fase são os seguintes:

4 — Categorizar e delegar: O agente Case Manager recebe a solicitação sanitizada. Se a solicitação for considerada legítima, o agente Case Manager deve verificar o histórico de compras e a cobertura da garantia; em seguida, inicia uma chamada segura de agent-to-agent (A2A) para o Agente Data Vault.

5 — Consulta no BigQuery: O agente Data Vault utiliza suas permissões exclusivas do IAM para acessar dados confidenciais e consulta dados das tabelas de Garantia e Vendas do BigQuery. Ele realiza verificações em números de série, datas de compra, etc., por meio do Google Cloud BigQuery MCP server.

6 — Status distillation: O agente Data Vault processa os dados brutos e os destila em um status conciso (ex.: “Coberto”, “Não Coberto”, “Expirado”). Durante essa avaliação, a IA também detecta incongruências (ex.: dados divergentes ou histórico suspeito), classificando o caso como “Suspeito”.

7 — Retorno de resultado: O agente Data Vault devolve ao Case Manager apenas o status destilado, a avaliação de anomalia e o PII mínimo necessário para a remessa.

Fase 3

O agente Case Manager orquestra a execução das ações reais através do agente Logistics Liaison, um serviço determinístico no Cloud Run focado unicamente na mecânica de cumprimento logístico, integrado a safeguards humanos e auditoria abrangente. Os componentes de arquitetura e a sequência de ações nesta fase são os seguintes:

8 — Handover logístico: O Case Manager orquestra o handover, encaminhando o status da garantia, os dados de remessa e quaisquer sinalizações de anomalia gerados por IA ao agente Logistics Liaison.

9 — Seleção de ação: O agente Logistics Liaison recebe a diretiva do agente Case Manager e aplica lógica determinística para encaminhar a execução:

a. Ramificação A (“Coberto”): Se o status for “Coberto” e nenhuma anomalia for sinalizada, o agente Logistics Liaison aciona as ferramentas MCP de Envio e E-mail para gerar uma etiqueta de envio de devolução premium e redigir um e-mail de confirmação, colocando a ação em uma fila interna para um clique final de “Aprovar” no HITL.

b. Ramificação B (“Expirado”): Se a garantia estiver “Expirada”, o agente Logistics Liaison aciona a ferramenta MCP de Oferta de Desconto para enviar automaticamente uma oferta de desconto em uma unidade de substituição.

c. Ramificação C (“Suspeito”): Se o payload dos agentes upstream incluir um indicador “Suspeito”, o agente Logistics Liaison aciona um código determinístico, ignora o processamento automatizado e encaminha a reclamação para uma fila de Fraudes & Alertas para análise humana imediata.

10 — Retorno de resumo de ação: Concluída ou sinalizada a ação, o agente Logistics Liaison envia um resumo ao agente Case Manager (ex.: “ID de substituição gerado: [ID], aguardando aprovação HITL”).

11 — Relatório final: Ao concluir suas tarefas de orquestração, o agente do Case Manager compila um relatório resumido. Este relatório engloba as principais conclusões (por exemplo, categoria do problema, status da garantia “Coberto”) e ações iniciadas. Este resumo é então gravado pelo agente Case Manager em um bucket do Cloud Storage para revisão comercial, registro a longo prazo ou análise potencial.

Nota: À medida que o agente Case Manager conclui o ciclo do fluxo de trabalho, as interações com o sistema, as comunicações A2A e as ações de atendimento geram registros que são capturados no Cloud Logging. Além disso, interações específicas com os serviços do Google Cloud, como o acesso a dados no BigQuery, também são registradas no Cloud Audit Logs.

Este foi o primeiro artigo da nossa série técnica baseada no whitepaper do Google Cloud sobre arquiteturas multiagente corporativas seguras.

Neste artigo, exploramos a jornada de atendimento do Sistema de Solicitação de Garantia e conhecemos a visão geral da arquitetura que divide responsabilidades entre três personas de agentes (Case Manager, Data Vault e Logistics Liaison) para impor fronteiras rígidas de segurança e menor privilégio.

O que vem a seguir no próximo artigo?

No próximo artigo, veremos em detalhes práticos:
 — Design seguro com SAIF (Secure AI Framework): Como proteger o raciocínio do modelo vs. as ações do agente;

— Por que abandonar Service Accounts tradicionais: A chegada do Agent Identity (identidades criptográficas vinculadas ao ciclo de vida via SPIFFE e mTLS);

— Implementação com ADK e MCP: Como blindar conexões ao BigQuery com callbacks determinísticos (BeforeToolCallback) e criar gatilhos de aprovação humana (HITL);

— Segurança na esteira de CI/CD: Proveniência com SLSA Nível 3 e controle de admissão de contêineres com Binary Authorization.

Acompanhe a série completa:
 — Parte 1: Introdução, Jornada do Usuário e Visão Geral da Arquitetura (este post)
 — Parte 2: Construindo e implantando uma arquitetura segura baseada em agentes
 — Parte 3: Interações de agentes e tempo de execução
 — Parte 4: Observabilidade e detecção de ameaças
 — Parte 5: Próximos passos: a abordagem crawl, walk, run

💬 Como sua equipe lida com limites de segurança entre múltiplos agentes de IA? Compartilhe suas experiências e desafios nos comentários!

👏 Se este artigo foi útil para você, deixe seus claps e siga o perfil aqui no Medium para não perder os próximos capítulos desta jornada técnica.

Construindo sistemas multiagente seguros no Google Cloud was originally published in google-cloud-brasil on Medium, where people are continuing the conversation by highlighting and responding to this story.

MedGemma, Google’s specialized variant of Gemma 3, represents a breakthrough in medical AI with its advanced capabilities for medical text and image comprehension. This comprehensive overview examines MedGemma’s performance in radiology and neurological examinations, comparing its effectiveness against traditional diagnostic methods and exploring the transformative potential for clinical practice.

Understanding MedGemma’s architecture

MedGemma leverages two sophisticated architectures optimized for medical applications:

MedGemma 4B multimodal system (we will use this one in the tutorial)

• Architecture: Decoder-only transformer with SigLIP image encoder
• Input processing: 896x896 resolution images encoded to 256 tokens
• Medical imaging specialization: Pre-trained on chest X-rays, CT scans, MRI sequences, and neurological imaging
• Context window: 128K tokens input, 8192 tokens output
• Variants: Available in both pre-trained and instruction-tuned versions

MedGemma 27B text analysis engine

• Optimization: Specifically designed for medical text comprehension and clinical reasoning
• Use Cases: Radiology report analysis, neurological assessment interpretation, clinical decision support
• Performance: Enhanced inference-time computation for complex medical reasoning

Key Medical Imaging Capabilities

Advanced image analysis

• Multi-modality support: X-ray, CT, MRI, PET scans
• Automated anomaly detection and localization
• Quantitative measurement extraction
• 3D reconstruction support for volumetric data

Clinical report generation

• Structured report creation from imaging studies
• Integration of clinical context with imaging findings
• Standardized terminology (RadLex, SNOMED CT)
• Multi-language support for global deployment

Real-time interpretation

• Immediate preliminary findings
• Priority flagging for critical conditions
• Integration with PACS and RIS systems
• Support for emergency radiology workflows

Artifacts

1.google/medgemma-4b-it

2. google/medgemma-27b-text-it

3.Radiology workspace on Hugging Face

How to use

You can use either with Vertex AI or Hugging Face.

In the Vertex AI Model Garden, you can see the overview of the model, as well as comprehensive performance metrics and detailed documentation.

The platform provides a centralized dashboard where developers can access benchmarking results, technical specifications, and implementation guides all in one place. It is the preferable way to use this model in production environments due to its enterprise-grade infrastructure, automatic scaling capabilities, and integrated monitoring tools that ensure reliable performance at scale.

You can select if you want to deploy as an online endpoint — to connect with your own applications through APIs, or as an enterprise notebook for interactive development and experimentation within the Google Cloud environment. The online endpoint option is ideal for integrating MedGemma into existing healthcare applications or building new services that require real-time inference capabilities, while the enterprise notebook provides a collaborative environment for data scientists and researchers to explore the model’s capabilities.

Users can select from different model variants (27B text-only or 4B multimodal versions), choose their deployment region, and configure from various machine specifications available.

The interface indicates that users may need to request additional quota if their desired GPU configuration isn’t available in their selected region (in this case, the quotas were approved almost immediately).

Once configured, the deployment process takes a few minutes to complete.

Deploy on Hugging Face

In this post, we will be covering the usage through Hugging Face, calling the model directly and using a GPU to execute it. This approach gives us more direct control over the model implementation and allows for detailed examination of its responses without the abstraction layers of managed services.

Since it is a gated model, you should accept the Terms and Conditions on Hugging Face in order to start using. You can also see the terms here.

The 4B parameter variant generally needs a GPU equipped with a minimum of 4 GB of video memory to run effectively. That said, the actual memory requirements can fluctuate based on the particular model configuration and any optimization methods like quantization that might be applied to reduce the computational footprint.

In the demo, I used the image below, and asked the model to describe it:

The model, even proposed to be used for research, has great results, as you can see in the Colab notebook.

**General Impression:**

The chest X-ray shows normal anatomical structures of the thorax.

**Key Observations:**

*   **Lung Fields:** The lung fields are relatively clear bilaterally. There are no obvious consolidations, opacities, or masses readily apparent.
*   **Heart Size:** The heart size appears within normal limits.
*   **Mediastinum:** The mediastinum (the central compartment of the chest containing the heart, great vessels, trachea, etc.) appears unremarkable.
*   **Bones:** The ribs, clavicles, and thoracic spine appear intact, with no evidence of fractures or significant degenerative changes.
*   **Diaphragm:** The diaphragmatic domes are well-defined.
*   **Costophrenic Angles:** The costophrenic angles are sharp and clear.
*   **Overall Impression:** The film is technically adequate

I tested this Chest X-Ray image with the model and, even though I’m not an expert, I could see that it noticed the differences in the lungs. This is a Chest X-Ray showing bilateral pulmonary changes. I observe diffuse opacities in both lungs, with a pattern suggesting inflammatory or infectious process. The changes appear more prominent in the lung bases and there’s a “ground glass” appearance or interstitial infiltrate.

Here is the model output:

Okay, I've reviewed the chest X-ray. Here's a description based on the image provided:

**Overall Impression:** The image shows a significant amount of opacity in the left hemithorax, likely representing a pleural effusion. The right lung appears relatively clear.

**Specific Findings:**

*   **Bones:** The ribs, clavicles, and other bony structures appear intact. There's no evidence of acute fractures.
*   **Lungs:** The right lung is relatively clear, with no obvious consolidations or masses. The left lung shows a large opacity occupying the lower portion.
*   **Pleural Spaces:** There's a substantial amount of fluid in the left pleural space, obscuring the normal lung markings. The fluid level is visible, indicating the presence of a pleural effusion.
*   **Heart Size:** The heart size appears within normal limits.
*   **Mediastinum:** The mediastinum (the space between the lungs

Conclusion

MedGemma represents a significant advancement in medical AI, particularly for radiology and neurological applications. With performance metrics consistently exceeding traditional methods in both accuracy and efficiency, this technology offers transformative potential for clinical practice. While designed for research and development purpose only (they are not clinical-grade tools and should not be used for actual patient care without proper validation and regulatory approval), MedGemma serves as a powerful augmentation tool that can enhance diagnostic accuracy, improve workflow efficiency, and ultimately lead to better patient outcomes.

The transition from traditional methods to AI-augmented practice requires careful validation, appropriate training, and thoughtful integration. However, the compelling performance advantages demonstrated across multiple imaging modalities and clinical scenarios suggest that MedGemma and similar technologies will play an increasingly central role in the future of medical imaging and neurological assessment.

References:

• Google Colab
• MedGemma: Advanced AI Models for Medical Text and Image Analysis | Google DeepMind
• MedGemma | Health AI Developer Foundations | Google for Developers
• MedGemma

Google has recently expanded its Gemini 2.0 model family with significant updates aimed at developers and production use cases.

The February 2025 announcement includes three key variants:

• Gemini 2.0 Flash (now generally available);
• Gemini 2.0 Flash-Lite (a new cost-efficient option in public preview);
• Gemini 2.0 Pro (an experimental update - focused on coding and complex tasks).

These releases follow the earlier introduction of Gemini 2.0 Flash Thinking Experimental, creating a comprehensive suite of models to address diverse application needs.

In the following sections, I’ll explore each new model in detail with practical code examples.

Gemini 2.0 Flash: The GA Workhorse

Gemini 2.0 Flash is positioned as Google’s workhorse model for daily tasks, combining enhanced performance with real-time capabilities. It represents an upgrade path for both 1.5 Flash users seeking better quality and 1.5 Pro users looking for better quality with real-time latency at a lower cost.

Key features

• Multimodal input: Process text, images, and video in a single prompt
• 1 million token context window: Process extensive documents and conversations
• Native tool use: Built-in function calling and tool integration
• Improved agentic capabilities: Better multimodal understanding, coding, and complex instruction following
• New modalities: Built-in image generation and controllable text-to-speech (in preview)

Code examples

• Basic text generation with Gemini 2.0 Flash

from google import genai
from google.genai.types import HttpOptions

# Configure for Vertex AI
import os
os.environ["GOOGLE_CLOUD_PROJECT"] = "your-project-id"
os.environ["GOOGLE_CLOUD_LOCATION"] = "us-central1"
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"

# Initialize client
client = genai.Client(http_options=HttpOptions(api_version="v1"))

# Generate content with Gemini 2.0 Flash
response = client.models.generate_content(
    model="gemini-2.0-flash-001",
    contents="Explain quantum computing in simple terms",
)

print(response.text)

• Multimodal example

from google import genai
from google.genai.types import HttpOptions
import PIL.Image

# Initialize client
client = genai.Client(http_options=HttpOptions(api_version="v1"))

# Open an image
image = PIL.Image.open("circuit_diagram.jpg")

# Create multimodal prompt
prompt = [
 "Analyze this circuit diagram and explain how it works:",
 image
]

# Generate response with multimodal input
response = client.models.generate_content(
 model="gemini-2.0-flash-001",
 contents=prompt
)
print(response.text)

Gemini 2.0 Flash-Lite: Cost-efficient option

Gemini 2.0 Flash-Lite is Google’s newest, most cost-efficient model variant, specifically optimized for large-scale text output applications. This model is ideal for high-volume, budget-conscious implementations while still delivering solid performance.

Key differentiators

• Cost optimization: Lowest-priced model in the Gemini family
• Scale focus: Designed for large-scale text processing applications
• Simplified pricing: Single price per input type with no distinction between short and long context
• Performance upgrade: Better quality for the same price and speed compared to 1.5 Flash

What Gemini 2.0 Flash-Lite includes:

• Multimodal input, text output: Process text and images as input, but produces only text responses
• 1M token input context window: Process extensive documents and conversations
• 8k token output context window: Generate comprehensive responses

What 2.0 Flash-Lite does not include:

• Multimodal output generation (no image or video generation)
• Integration with Multimodal Live API
• Thinking mode
• Built-in tool usage

Note: Some features available in 1.5 and lower models are not yet available for 2.0 models (for example, provisioned throughput and batch prediction). For complete Gemini 2.0 technical details, refer to the Google documentation about their models.

Code examples

• Processing large volumes of text

from google import genai
from google.genai.types import HttpOptions

# Initialize client
client = genai.Client(http_options=HttpOptions(api_version="v1"))

# Process large volumes of text efficiently
def process_customer_feedback(feedback_list):
    results = []
    for feedback in feedback_list:
        response = client.models.generate_content(
            model="gemini-2.0-flash-lite",  # Using Flash-Lite model ID
            contents=f"Categorize this customer feedback as positive, negative, or neutral and extract key themes: {feedback}",
        )
        results.append(response.text)
    return results

feedback_samples = [
    "Your product has greatly improved my workflow. The interface is intuitive, though I wish there were more customization options.",
    "I've been experiencing frequent crashes when using the export feature. This is frustrating and causing delays in my work.",
    # ... more feedback items
]

analysis_results = process_customer_feedback(feedback_samples)
print(analysis_results)

Gemini 2.0 Pro: For complex tasks and coding

Gemini 2.0 Pro represents Google’s experimental update focused on advanced coding capabilities and handling complex prompts. This variant is designed for developers working on sophisticated applications that require high-quality code generation and nuanced reasoning.

Specialized capabilities

• Advanced coding: Improved code generation, debugging, and explanation
• Complex reasoning: Better handling of multi-step problems and nuanced instructions
• Experimental features: Access to cutting-edge capabilities still under development

Code examples

• Function calling with Gemini Pro

from google import genai
from google.genai.types import HttpOptions, FunctionDeclaration, Tool

# Initialize client
client = genai.Client(http_options=HttpOptions(api_version="v1"))

# Define function for weather information
get_weather = FunctionDeclaration(
    name="get_weather",
    description="Get current weather information for a location",
    parameters={
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "City and state, e.g., 'San Francisco, CA'"
            },
            "unit": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["location"]
    }
)

# Create a tool with this function
weather_tool = Tool(
    function_declarations=[get_weather]
)

# Example user query that might require weather information
response = client.models.generate_content(
    model="gemini-2.0-pro-001",
    contents="What should I wear for my trip to Seattle tomorrow?",
    tools=[weather_tool],
    tool_config={"function_calling_enabled": True}
)

print(response.text)
# In actual implementation, you would handle the function call by retrieving
# weather data from a real API based on the model's function callfrom google import genai

Choosing the right Gemini 2.0 Model

Selecting the appropriate model within the Gemini 2.0 family depends on your specific use case, performance requirements, and budget constraints:

2.0 Flash

• General purpose applications
• You need a balance of performance and cost with GA features

2.0 Flash-Lite

• High-volume text processing
• Budget is a primary concern for large-scale operations

2.0 Pro

• Coding and complex tasks
• You need the highest quality for challenging problems

2.0 Flash Thinking

• Problems requiring reasoning
• Accuracy is more important than response speed

Whether you’re building a simple chatbot or a complex AI-powered application with sophisticated reasoning capabilities, there’s likely a Gemini 2.0 variant that fits your requirements.

Start exploring these models today with the code examples provided and see what you can build! 🥳

O que é o DataGemma?

Recentemente, Google anunciou seu novo modelo DataGemma - um modelo aberto colocado para trazer respostas mais conectadas a fatos em LLMs. Ele busca ancorar as respostas desses modelos em dados reais, utilizando o Data Commons do Google — um vasto repositório de dados públicos confiáveis com mais de 240 bilhões de data points de fontes como a ONU e o CDC.

No paper oficial, são trazidas as duas principais abordagens utilizadas pelo DataGemma:

1. RIG (Retrieval-Interleaved Generation): Quando a consulta envolve dados estatísticos, o modelo recupera e verifica as informações no Data Commons antes de gerar a resposta. Esse método permite que o modelo consulte dados de fontes confiáveis e os incorpore diretamente na resposta, aumentando a precisão.
2. RAG (Retrieval Augmented Generation): O modelo recupera dados relevantes do Data Commons antes de gerar a resposta, incorporando essas informações ao contexto para melhorar a precisão. Como o volume de dados recuperados pode ser grande, é necessário usar LLMs com grandes janelas de contexto, como o Gemini 1.5 Pro, que suporta um número significativo de tokens.

De forma prática, o RIG envolve o fine-tuning do LLM para gerar consultas em linguagem natural direcionadas ao Data Commons, além de fornecer estatísticas. Uma pipeline converte essas consultas em uma query estruturada, que é usada para obter respostas do banco de dados do Data Commons. Os resultados são comparados com os modelos básicos Gemma 7B IT e 27B IT.

O RAG segue uma metodologia mais tradicional de recuperação de informações. O modelo extrai variáveis mencionadas na consulta, recupera dados relevantes do Data Commons e amplia a consulta original com esse contexto, gerando a resposta com o LLM (no caso, o Gemini). Os resultados são comparados com o modelo base Gemini 1.5 Pro.

Os testes iniciais mostraram que a integração com o Data Commons via RIG e RAG melhora significativamente a precisão dos LLMs, especialmente em perguntas que exigem respostas baseadas em fatos. Em particular, o uso de RIG resultou em uma precisão de cerca de 58% nos casos em que o Data Commons retornou a estatística correta, contrastando com apenas 5–17% de precisão quando os LLMs tentaram gerar respostas sem recuperar dados.

Avaliação

O que eu particularmente gosto de olhar em papers desse tipo são os métodos de avaliação, visto que essa parte se contrasta muito dependendo da metodologia.

Algo que achei pertinente trazer (e que recomendo que seja revisado no paper pois é bastante didático) é a criação de uma ferramenta de foi colocada nas mãos de avaliadores.

Nessa ferramenta, são separados estágios de avaliação. Na avaliação do RIG, por exemplo, há um estágio inicial que seria o de avaliar a resposta num geral — considerando problemas com os fatos gerados, e um segundo momento que é o de avaliar estatísticas.

Trabalho em andamento

Apesar de bastante promissor o método, ele ainda está em fase de testes pela comunidade acadêmica e a empresa está em análise de feedbacks para conseguir conectar esse modelo a uma gama maior de use cases.

Um desafio bastante importante é a cobertura de dados no Data Commons, que é limitada em algumas regiões fora dos EUA. Além disso, o processo de geração de consultas precisas para o Data Commons ainda pode ser aprimorado.

Enquanto pesquisas visam melhorar o treinamento do modelo e expandir a base de dados do Data Commons para aumentar sua eficácia global, fiz alguns testes em um notebook e deixo o link aqui, para que você possa visualizar como funciona o workflow.

No notebook referenciado acima, você pode fazer uma cópia e testar você mesmo com suas próprias frases após realizar o setup dos modelos.

É importante que você siga alguns passos:

1. Ter uma conta no Hugging Face, Google AI Studio e Data Commons.
2. Aceitar a licença do Gemma no Hugging Face.
3. Criar os secrets necessários para rodar o notebook conforme instruções estipuladas nele (isso envolve criar chaves de API que serão necessários para executar as instruções).
4. E pronto! ✨

Se você tiver qualquer dúvida, deixe nos comentários.

Espero que tenha gostado desse tutorial.

Até o próximo!

Introduction

Recently, the Artificial Intelligence field has witnessed an accelerated pace of innovation, with new models being unveiled rapidly. Multimodality, in particular, has become a focal point of discussion this year, illustrating how the integration of diverse data types and input modalities is revolutionizing technology. These multimodal models, which synergize visual, textual, and sometimes auditory data, are leading this transformative wave, showcasing their ability to comprehend and process a vast array of human information more effectively.

In this dynamic landscape, the significance of computer vision models has soared, proving vital across a range of practical applications, from image recognition to real-time video analysis. Their relevance extends to the advancement of more cohesive and accessible intelligent systems.

This tutorial will explore Gemini Pro Vision capabilities — a prime example of a multimodal model that captures the essence of these AI advancements. By combining sophisticated computer vision with natural language processing and additional modalities, it can help in various domains of application.

A prime instance of multimodal models’ utility is Visual Question Answering (VQA), where the model interprets images and text together to respond to inquiries about an image. This function demonstrates the potent combination in multimodal AI, enabling models like Gemini Pro Vision to not only perceive but also analyze and articulate visual data within a meaningful context, greatly enhancing user engagement and accessibility.

What Exactly is VQA?

Visual Question Answering (VQA) is a field of artificial intelligence that combines techniques from computer vision and natural language processing to enable machines to answer questions about images.

In a VQA system, the model is provided with an image and a text-based question about the image. The goal is for the model to analyze the visual content and then generate a relevant, accurate answer based on that analysis.

Here’s how VQA typically works:

• Image Analysis: The model uses computer vision techniques to understand the content and context of the image. This might involve recognizing objects, their attributes, and relationships between them.
• Question Understanding: The model processes the question, often using natural language processing techniques, to understand what is being asked.
• Answer Generation: After analyzing both the image and the question, the model synthesizes the information to produce an answer. This can be in various forms, such as a word, phrase, sentence, or even a number.

Gemini Pro Vision

Gemini 1.0 Pro Vision is a model developed by Google which supports multimodal prompts. You can include text, images, and video in your prompt requests and get text or code responses.

Some technical details from the documentation:

• Last updated: December 2023
• Input: text and images
• Output: text
• Can take multimodal inputs, text and image.
• Can handle zero, one, and few-shot tasks.
• Input token limit: 12288
• Output token limit: 4096
• Model safety: Automatically applied safety settings which are adjustable by developers.
• Rate limit: 60 requests per minute

Those models are improving fast, so this information can get deprecated really soon (as the old PaLM APIs — from few months ago). Actually, the word “old” got a different meaning after this rush of AI.

Getting Started with Gemini Pro Vision

Alright, it’s coding time.

Since we’re discussing images, I took advantage of my full camera roll and revisited my recent trip to Singapore, where I attended a Google event for Developer Creators and Online Communities.

I had the opportunity to visit the National Orchid Garden, where I took numerous pictures to show my mom, as her favorite flower is the orchid. I will use this one, as it also features her favorite color.

Before diving into the Colab Notebook, where I’ve integrated the step-by-step guide with the code, I want to point out that you’ll need an API key to use the model featured in this tutorial.

To obtain this API key, you should visit https://aistudio.google.com/ and navigate to the “Get API Key” section. The process is quite straightforward!

For reference, here’s the tutorial link:

• Colab version
• Github version

If you have any questions, feel free to leave a comment in this article.

I hope this helps you understand the potential of these models! 👋

[ML Story] Asking questions to images with Gemini Pro Vision was originally published in Google Developer Experts on Medium, where people are continuing the conversation by highlighting and responding to this story.

Your go-to solutions to prototype and dive into Large Language Models by Google

Introduction

The way we approach problem-solving as humans has undergone a significant transformation with the widespread adoption of Large Language Models (LLMs). In the past, tackling tasks such as summarizing documents or classifying a sentence with a computer necessitated the creation of a complex program— essentially a set of meticulously crafted commands in a specific programming language. However, with the advent of LLMs, addressing these challenges now simply involves providing a textual prompt.

Today, describing the desired appearance of a website allows us to obtain not only a comprehensive set of files but also, in certain cases, a pre-deployed application. This seamless process is made possible through the integration of automation and specialized tools, streamlining the development and deployment of websites.

But to get the most powerful results from LLMs, it is important to explore different techniques. In this article, I will present a beginner’s strategy for Prompt Engineering, intending to cover more advanced techniques in the subsequent articles of this series. To accomplish this task, I will utilize MakerSuite and the Palm API. Assuming you are already familiar with Large Language Models, I will skip introductions to this particular subject and instead introduce you to the tools we will be using in this tutorial.

MakerSuite and PaLM API

Like GPT models, PaLM is a transformer-based large language model offered by Google as an API service. The interpretation of multiple LLM providers (OpenAI, Google, Anthropic…) can be valuable for making the right design decisions for your application, such as model selection and limitation identification.

At the time of this article, you can access PaLM APIs using three different methods: MakerSuite, Vertex AI Libraries, and Vertex AI APIs. The last two are suitable for those who are already familiar with GCP and its ML infrastructure. You also gain access to all available models on Google using these methods.

In this article, we will focus on MakerSuite to access our models. MakerSuite is powerful due to its friendly interface (similar to common LLMs API providers) and is very easy to set up, requiring only an API key. You can prototype your application with a set of prompts, datasets, and custom-tuned models. It is easy to play around with the interface, allowing you to change the standard features of the model — such as the type of the model, temperature, max outputs, etc. As a final result, you are able to see the code and embed it in your own apps.

Google has made it easy to set up access to the Palm API on MakerSuite. Now, you don’t need to set up a Google Cloud Platform environment, configure service account roles, etc., as you would have to do using Vertex AI Libraries and APIs. Users can easily access a specific model outside the common console from Google Cloud.

At the time of this article, MakerSuite is not yet available in Brazil, requiring access through a VPN. However, in most countries, it is already accessible, so it should become available worldwide soon.

When accessing MakerSuite, a crucial message promptly appears, highlighting important considerations, particularly if you intend to deploy these models in production without response checks, such as the implementation of guardrails.

The APIs are currently in limited general availability. You may use them for production use but Google may enforce rate limits during this period.

Don’t submit sensitive (e.g., confidential) or personal information.

PaLM API is experimental technology and may sometimes provide inaccurate or inappropriate information that doesn’t represent Google’s views.

Don’t rely on responses as medical, legal, financial, or other professional advice.

As you proceed, obtain an API key (accessible through the menu once you accept the preceding terms). Remember to treat this key with the utmost confidentiality — do not share it with anyone and securely store it, as you won’t be able to retrieve it later, necessitating the creation of a new one.

In the Prompt Gallery, you can discover various approaches for your applications, categorized by Google into three sections: ‘Text,’ ‘Data,’ and ‘Chat.’ Depending on the scenario, a model will be assigned — text-bison-001 (e.g., summarization, QnA) or chat-bison-001 (e.g., iterative applications like chatbots and conversations).

Text use-cases

Bison is one of the largest models developed by Google. le. While it may not be the largest (in ascending order, the sequence is Gecko, Otter, Bison and Unicorn), it still delivers exceptional results.

To create a text model example, I navigate to the Prompt Gallery and choose the ‘Style rewrite’ example, which is useful for rewriting text in a specific style.

When opened in MakerSuite, you’ll find the interface with predefined settings for this use case. The most interesting part is the ease of attaching it to your app with the “Get Code” functionality. This button opens a pop-up with code similar to the example below:

!pip install google-generativeai

import google.generativeai as palm
palm.configure(api_key="YOUR API KEY")

defaults = {
  'model': 'models/text-bison-001',
  'temperature': 0.9,
  'candidate_count': 1,
  'top_k': 40,
  'top_p': 0.95,
  'max_output_tokens': 1024,
  'stop_sequences': [],
  'safety_settings': [{"category":"HARM_CATEGORY_DEROGATORY","threshold":1},{"category":"HARM_CATEGORY_TOXICITY","threshold":1},{"category":"HARM_CATEGORY_VIOLENCE","threshold":2},{"category":"HARM_CATEGORY_SEXUAL","threshold":2},{"category":"HARM_CATEGORY_MEDICAL","threshold":2},{"category":"HARM_CATEGORY_DANGEROUS","threshold":2}],
}
prompt = f"""The girl walked to the store, her pockets full of change. She hopped and skipped and danced her way downtown, change rustling like a tambourine. She had been saving up for weeks, and today she was extremely excited, as it was the day she was finally going to buy a pack of her favorite bubble gum. She couldn't wait to blow the biggest bubbles in the world.

Rewrite this story as a superhero origin story.


"""

response = palm.generate_text(
  **defaults,
  prompt=prompt
)
print(response.result)

I used the Python code snippet, but it’s also available in other languages.

With the code snippet above, we can already observe relevant details:

1. It was already generated using the text model, in models/text-bison-001.
2. In addition to the common configurations found in the setup of other LLMs (such as temperature, top_k, top_p…), we have the safety_settings, which I will highlight now. This parameter helps us align with Responsible AI principles, mitigating potential harm, toxicity, and violence in our applications. You can configure your openness to accepting each type of content, blocking medium or high probabilities of being unsafe, for example.

In the pop-up, you should see a “Open in Colab” button, making it easy for you to delve into your example in the Cloud using the notebook environment you are already familiar with.

Chat use-cases

If you’re planning to develop a chatbot or a conversational application, your go-to model should be a Chat one, specifically chat-bison-001.

Returning to the Prompt Gallery, navigate to the ‘Talk to snowman’ example. However, in our case, we’ll make some adjustments to make it more suitable for a professional scenario.

Upon opening in MakerSuite, proceed to “Get Code” again and click on the “Open in Colab” option. In Google Colab, click on “Connect” on the right side of the screen. Afterward, modify the configuration to include your API key in the second cell. Following these steps, you are ready to go and can run all the cells.

You should see output similar to the example below:

Yes, I melt. I'm made of snow, and snow melts when it gets warm. I'm not sure how long I'll last, but I'm enjoying my time here while I can!

It’s interesting, but unless your company is in a field related to snowmen or it’s during the Christmas period, you probably won’t use an example exactly like this in your applications. To create something more aligned with our reality, I’ll return to MakerSuite to demonstrate how you can do it in the UI (you can also do it in Colab, but for this tutorial, I want to showcase the interaction with the interface).

First, keep only one example of interaction between the user and the model, removing all others.

In “Context”, replace the current text with the following one:

Act as a Senior Software Engineer. You are an expert in designing distributed systems and takes into account scalability and design patterns in our solutions. Answer the questions with short responses.

Add the following in the “User Input”:

How can I create a scalable Python architecture?

For the “Model Input”, paste the following (generated using Bard):

To create a scalable Python architecture, you need to consider the following factors:

Use concurrency and parallelism. Python has a number of features that can be used to implement concurrency and parallelism, such as threads, processes, and asynchronous programming. By using concurrency and parallelism, you can distribute your workload across multiple cores and processors, which can improve the performance and scalability of your application.
Use a message queue. A message queue is a distributed messaging system that can be used to decouple different components of your application. This can make your application more scalable and resilient to failures.
Use a distributed database. A distributed database is a database that is spread across multiple servers. This can improve the performance and scalability of your application by distributing the load across multiple machines.
Use a caching layer. A caching layer can be used to store frequently accessed data in memory. This can improve the performance of your application by reducing the number of database queries that need to be made.
Use a load balancer. A load balancer can be used to distribute traffic across multiple instances of your application. This can improve the performance and scalability of your application by handling increased traffic.
Here are some additional tips for creating a scalable Python architecture:

Design your application with scalability in mind. When designing your application, think about how it will scale as the number of users and requests increases.
Use a modular architecture. A modular architecture makes it easier to add new features and scale your application.
Use a configuration management tool. A configuration management tool can help you to manage the configuration of your application across multiple servers.
Monitor your application. It is important to monitor your application to identify any performance bottlenecks or scalability issues.
There are a number of Python frameworks and libraries that can be used to implement the above principles. Some popular options include:

Celery for asynchronous programming
RabbitMQ for message queuing
PostgreSQL and MySQL for distributed databases
Redis for caching
Gunicorn and Nginx for load balancing
By following the above tips and using the appropriate frameworks and libraries, you can create scalable Python architectures that can handle large volumes of traffic and data.

Now, in the “Test your prompt” window, type “And how would I do in Java?”, exactly as shown, and we are ready! You can observe how your model performs with this provided example.

You can also modify other configurations by clicking on the model’s name in the top left corner of the screen.

Closing remarks

Thank you so much for reading this article. It’s the first in a series that I’m planning to write related to Prompt Engineering and how to address various challenges we may encounter with Large Language Models. Expect more advanced articles in the future.

Due to the rapid advancements in this field, this tutorial may become outdated quickly. I’ll review it periodically to see if any adjustments are needed.

I hope you found it helpful, and I look forward to your feedback!

Exploring Generative AI using MakerSuite and PaLM API was originally published in Google Developer Experts on Medium, where people are continuing the conversation by highlighting and responding to this story.

O número de dados que produzimos está cada vez maior com o passar dos anos. Junto a isso, há a descoberta de que esses dados podem trazer um valor imenso para o negócio e que podem “opinar” sobre importantes decisões nos mais diversos segmentos, dando origem à frase “data is the new oil”.

Esses são alguns dos fatores que fazem com que a carreira de ciência de dados esteja entre as mais solicitadas por diversas empresas, como é possível ver seu crescimento através do gráfico abaixo com dados do LinkedIn.

Neste artigo, irei apresentar um overview sobre essa carreira, abordar alguns dos principais pontos desta área para quem possui interesse em se reinventar como um(a) cientista de dados e dicas e sugestões de alguém que já passou por muito do que está aqui, errou, aprendeu e quer ajudar a fazer desta jornada a mais prazerosa possível para as pessoas interessadas em ingressar nesse navio (Titanic, competição, Kaggle… você vai entender a piadinha mais pra frente 😂)!

Como eu comecei na área?

Hoje atuo com ciência de dados na CI&T. Iniciei na carreira (atuando na profissão dentro de uma empresa, das 8h às 17h) no início de 2019. A parte interessante disso tudo é que, antes mesmo de 2019 começar, já tinha uma história iniciada e meus olhos já brilhavam pela área.

Tudo começou em junho de 2018, em um evento chamado Xamarin Summit, da Microsoft. A empresa em que eu trabalhava no momento era patrocinadora do evento, e possuía direito a alguns slots no evento para levar seus colaboradores para palestrar.

Eu sempre fui envolvida com comunidades, desde minha faculdade. Fazia palestras, publicava artigos, respondia dúvidas em fóruns e contribuía da forma que eu podia, intrinsecamente.

A empresa me chamou para ocupar um desses slots devido à facilidade que eu possuía com a comunicação e por já ter criado alguns aplicativos móveis com a tecnologia que o evento cobria. Eu aceitei o convite sem pestanejar, até porque era a primeira vez que eu iria me apresentar em uma empresa que tanto estimava, e numa conferência tão grande. Lembro até hoje como fiquei.

Chegada a hora de escolha do tema e da preparação do conteúdo. Nesse momento, eu era uma desenvolvedora C# pleno, avançando para sênior, que não se envolvia com o mundo mobile há alguns meses e já não estava por dentro das últimas novidades de suas tecnologias e diferentes frameworks. O que levar de diferente e que possa agregar algo para o público que ia me assistir?

Foi aí que, depois de muita pesquisa, conheci o assunto de chatbots, processamento de linguagem natural e speech to text/text to speech. “Esse tópico é interessante? Deixa eu ler… MUITO! Esse tópico já está presente na grade? Hm… ainda não!” Eureka!

Comecei a estruturar a palestra. Encontrei um tutorial na internet sobre API’s cognitivas, comecei a chamá-las dentro do aplicativo que desenvolvi e o chatbot foi criando forma. Era época de copa do mundo, então desenvolvi um chatbot para o salão de beleza da Rochelle, mãe do Chris de Todo Mundo Odeia o Chris, e quem falava com ela era o Neymar, procurando um tratamento para queda (🥳).

No dia do evento deu tudo certo! Palestrei sobre o assunto e muitas pessoas falaram sobre o tema e gostaram muito! Nele, conheci muitas pessoas que eu admirava e que possuíam o título de MVP (Microsoft Most Valuable Professional) que eu nem imaginava que conquistaria um ano depois.

Fui para casa extremamente feliz, e disposta a continuar estudando a área. A cada dia que passava, eu me interessava ainda mais por entender o que estava por trás daquelas API’s que eu havia chamado dentro do meu aplicativo — como elas retornavam aquelas informações de acurácia, de treinamento, e suas métricas. Comecei a estudar a matemática, a estatística, os modelos de machine learning e tudo que tange ciência de dados, criando minhas próprias API’s e entendo o que tinha por trás daquela caixinha preta.

Em setembro de 2018, conversei com o CEO da empresa que eu estava na época sobre a vontade de criar uma área de Inteligência Artificial na empresa. Mostrei a ele como as aplicações poderiam trazer valiosos insights para o negócio, e tudo o que eu havia estudado até aquele momento. Eu continuava como desenvolvedora profissionalmente, mas todos os dias quando chegava em casa me afundava em uma outra ciência. Eu queria focar naquilo, e estava decidida.

Essa área foi iniciada após eu conseguir provar o valor que ela possuía e me disponibilizar para formar colaboradores para atuarem em projetos que envolviam dados. Criei um plano de estudos, selecionei com carinho os conteúdos que deveriam aprender para conseguir colocar a mão na massa, coloquei várias dicas para evitar que passassem pelas várias dores que o autodidatismo me permitiu passar — e que valorizo até hoje — mas tornam o caminho mais tortuoso.

E assim nasceu a área que tanto sonhei. Nosso primeiro projeto chegou, e eu e mais 4 pessoas estávamos responsáveis para seu sucesso acontecer. Me vi feliz e realizada, pois atuava como líder da primeira área de ciência de dados da empresa e conseguia colocar em prática aquilo que tanto tempo de estudo me agregou, e formar pessoas a partir da minha pouca experiência.

Tive outras experiências com ciência de dados, iniciei em novos desafios e hoje sigo procurando impactar negócios e pessoas fazendo os dados falarem.

Comecei pela matemática? Não! Comecei pelo fim. Eu tinha um objetivo e fui destrinchando ele. Iniciei com API’s, e depois fui, de pouco em pouco, entendendo o que havia por trás delas. Isso, na minha opinião, deixou as coisas mais fáceis, porque minha formação era principalmente de engenharia de software, e não de matemática e estatística.

O que é Data Science?

Antes de iniciarmos a lista de pontos interessantes para entrar na área de ciência de dados, é importante definir o que é essa área.

A ciência de dados, de forma genérica, é a área que estuda os dados e tira deles informações relevantes. É através dela que hipóteses são testadas e validadas (quando possuímos um problema específico para ser resolvido com os dados) ou que a análise exploratória acontece (quando temos uma grande quantidade de dados dispersos e tiraremos conclusões e correlações deles).

O maior objetivo dessa área é extrair tais dados, interpretá-los e apresentá-los de forma eficaz para o usuário final, nivelando a linguagem conforme o público com o qual se comunica (saber apresentar para pessoas técnicas e pessoas que não possuem conhecimento no assunto).

O guarda-chuva da ciência de dados

Com o crescimento da área, algumas das vertentes do pipeline de ciência de dados tomaram grandes proporções e necessitaram de profissionais específicos para cuidarem de seu correto andamento. Tais profissionais entendem do pipeline como um todo com uma visão generalista mas veem cada uma das áreas, de acordo com sua preferência, com um olhar especialista. O diagrama abaixo representa uma ideia disso (que pode variar):

• Analista de dados: especialistas em relatórios e visualização, são profissionais que auxiliam na tomada de decisão a partir das informações que geram e comunicam. Analisam as informações obtidas dos processos e trazem relações entre elas, traduzindo-as para o uso no dia-a-dia. Possuem um maior foco em responder perguntas e gerar suas respostas de forma rápida e precisa.
• Engenheiro(a) de dados: profissional focado(a) na extração dos dados e tratamento dos mesmos. Se especializa no processo de obtenção dos dados, das mais diversas fontes, e é capaz de tratá-los a fim de garantir que os modelos de machine learning recebam os inputs necessários para fazer as predições corretas. São responsáveis pela modelagem dos dados, pela mineração e paralelismo, utilizando frequentemente ferramentas de ETL (Extract, Transform e Load) para esse processo.
• Machine Learning Engineer: aprimoram a capacidade e desempenho dos modelos preditivos criados e são responsáveis por garantir que tais modelos terão um bom desempenho quando em ambiente de produção. Possuem grande conhecimento em algoritmos de machine learning e em arquitetura, desde a modelagem até o monitoramento, garantindo escalabilidade e um pipeline de Continuous Integration/Continuous Delivery consistente.
• Cientista de dados: responsável desde o processo de concepção do problema, auxiliando a área de negócio em suas decisões e no caminho que deve ser seguido com autonomia e criatividade, até a entrega da solução; emprega métodos de aprendizado de máquina para a preparação de modelos preditivos, explorando oportunidades e tendências. É a pessoa que, de todas as áreas, possui o maior entendimento do processo de ponta a ponta, sendo capaz de construir modelos preditivos e apresentá-los para a área de negócio de forma compreensível sem perder sua base científica. Possui grande embasamento matemático e estatístico.
• Estatista: atua principalmente junto do cientista de dados com o conhecimento estatístico que possui para a criação e gerenciamento de modelos preditivos. Tem a habilidade de utilizar teorias, probabilidade e matemática para transformar problemas cotidianos e encontrar suas soluções. É o(a) profissional que menos tem contato com engenharia de software, e mais tem contato com estatística e álgebra linear.

Obs.: não tente se aprofundar em tudo. Tentar ser um unicórnio (🦄), que tem todas as skills, não vai dar certo — o mundo é muito grande e sempre tem algo novo saindo!

Alinhando expectativas

O erro mais comum de alguém que está entrando em ciência de dados é acreditar que irá apenas criar modelos de machine learning.

A criação de modelos de machine learning acontece sim, dependendo principalmente da subárea que você escolha se aprofundar. No entanto, mesmo que você opte por uma área que, majoritariamente, cria modelos, você não fará isso 100% do tempo, porque:

1. Essa é uma área que as empresas ainda estão entendendo como implantar, então você provavelmente fará muitas coisas que não tangem apenas seu papel;
2. Você pode vir a encontrar dados que estão de forma totalmente desorganizada, ou até não ter dados suficientes. Precisará tratá-los, limpá-los, uniformizá-los. Se você não tiver uma boa base de dados para trabalhar — e não tiver noções de feature engineering (transformar dados não tratados em um dado de valor que represente melhor o problema para os modelos preditivos)—você não terá um modelo que funciona adequadamente, e pode se frustrar.

Defendo a ideia de que ciência de dados é sobre um pipeline como um todo, e não apenas algoritmos.

A lista que vem tem bastante coisa. Bastante mesmo! Não tente absorver tudo de uma vez. Eu mesma estou me aperfeiçoando em cada um dos pontos e não me considero fluente em todos, até porque nossa área é a que mais se atualiza e todos os dias temos coisas novas para estudar.

Faça do processo de aprendizado, algo prazeroso!

A lista

1) Análise e entendimento do negócio

Antes mesmo de mais nada, é importante sempre lembrar que tecnologia é meio, e não fim. No final do dia, o que realmente trará valor serão os resultados gerados a partir das implementações que fazemos, quer elas envolvam ferramenta a, b ou c.

O trabalho junto ao business vai acontecer, porque muitas vezes tem-se um problema para se solucionar que parece turno, e é necessário melhor entendimento — às vezes, nem problemas se tem. Skills importantes são pensamento crítico, capacidade de resolver problemas e senso de urgência.

E como conseguir isso, quando se deseja entrar na área e não se trabalha nela e em nenhum projeto para colocar isso em prática? O Kaggle possui uma série de projetos que você pode utilizar como ponto de partida para exercitar sua capacidade de organização de pensamento e traçar uma linha de raciocínio que possibilite a resolução do problema. Além disso, há várias competições no site, que possibilita que você de fato simule um cenário onde você precisa ter pensamento veloz.

Outra dica é utilizar notebooks (como Jupyter e Colab) para documentar sua linha de raciocínio e simular como apresentaria as informações que coletou, desde seu início até suas conclusões. Isso pode ser útil mais pra frente, quando você for criar seu portfólio.

📌 Kaggle

📌 Jupyter Notebook

📌 Google Colab

2) Linguagens e Programação

Você vai sim, precisar programar. Em todas as subáreas a programação é importante, o que difere é a linguagem que uma utiliza mais do que a outra.

Conhecimento em linguagens como Python e R é importante. Você não precisa ser especialista em ambas; sugiro que escolha uma para se especializar e saiba seus limites e as diferenças em comparação com a outra. Eu, por exemplo, escolhi me especializar em Python e ele solucionou meus problemas em todos os aspectos até hoje, por ter suporte tanto para construção de algoritmos quanto para expor suas API’s na web (com Flask ou Django).

Há outras linguagens, como Java e C, que são utilizadas em vez de Python e R em alguns projetos. Defendo que, uma vez que você conhece programação, o que mais difere entre uma linguagem e outra é a sintaxe e a maneira de implementação, mas a lógica para resolver o problema é a chave.

Banco de dados também será muito utilizado! Bancos relacionais e não relacionais podem aparecer pelo seu caminho. Por isso, é importante ter noções de SQL (como Microsoft SQL Server), NoSQL (como MongoDB), Spark e Scala e ir avançando para Hadoop, Hive, Kafka e MapReduce para cobrir soluções em Big Data e conseguir participar de discussões sobre esse tipo de assunto.

Ainda sobre programação, não esquecer de pontos como escalabilidade, testes, código limpo, versionamento de código e boas práticas de desenvolvimento é crucial. Esse tipo de preocupação fez parte dos meus anos como desenvolvedora web e continuam presentes mesmo como cientista de dados.

📌 Repositório de Web Scrapping, no meu github

📌 Python para Zumbis, do Fernando Masanori

📌 Python Fluente, do Luciano Ramalho

📌 Cursos da edX

📌 A Beginner’s Guide to R, livro gratuito por pouco tempo no site da Springer (corre baixar, Forrest, corre!)

📌 MongoDB University

📌 Blog com conteúdos do básico ao avançado sobre SQL, do Fabiano Amorim.

📌 Artigo com dicas sobre SQL, da Dani Monteiro

📌 Playlist sobre SQL Server, do Bóson Treinamentos

📌 Código Limpo, do Robert C. Martin

📌 Documentação do Docker (para DevOps e escalabilidade)

3) Machine Learning

Existem muitos modelos de machine learning, vários já pré-treinados com diversos dados e que já estão prontos para utilização.

É importante entender aqui para que servem esses modelos e os tipos aos quais se enquadram, por exemplo:

• Supervisionado: os dados de treinamento que estão no dataset de treino do algoritmo possuem as categorias (chamadas de labels) do output do modelo. Basicamente, nós mostramos onde queremos chegar. Exemplos: K-Nearest Neighbors, Linear and Logistic Regression, Support Vector Machines (SVM’s), Decision Trees and Random Forests, Neural Networks.
• Não-supervisionado: os dados de treinamento não estão no dataset de treino e o sistema tentará chegar ao output através de propriedades semelhantes entre cada um dos dados, sem guia ou auxílio. Exemplos: K-Means, Hierarchical Cluster Analysis (HCA), Principal Component Analysis (PCA).
• Semi-supervisionado: os dados de treinamento que estão no dataset de treino do algoritmo possuem parcialmente as categorias.
• Por reforço: neste tipo de aprendizagem, o modelo é chamado de agente e realiza ações em busca de recompensas, tendo como objetivo sempre aumentar esse número. É como adestrar seu cachorro e dar um biscoito a ele sempre que ele deita, por exemplo.

Adicionei abaixo uma lista com exemplos dos vários modelos existentes, cada um sendo utilizado para uma abordagem específica.

Entender modelos de regressão, de classificação, de clusterização é bem interessante e conseguirá te diferenciar quando for procurar uma oportunidade no mercado.

Bibliotecas e frameworks que podem estar presentes no seu dia a dia (voltadas para Python):

Extração dos dados e pré-processamento (foco em texto)

📌 Spacy

📌 NLTK

📌 Beautiful Soup

📌 Selenium

Transformação:

📌 Pandas

📌 Numpy

Modelagem:

📌 Tensorflow

📌 Keras (incorporado no Tensorflow 2.0)

📌 Scikit Learn

📌 PyTorch

Para áudio:

📌 LibROSA

Para imagem:

📌 OpenCV

Ah, já ia me esquecendo: GPU. Mano do céu, isso salva vidas — e tempo! Com a GPU, você consegue ter alta capacidade de processamento e treinar seus algoritmos mais rápido. Você talvez já ouviu falar dela ao ver sobre PC’s gamers, e agora consegue visualizar mais uma aplicação sua! Saiba mais sobre ela aqui.

Sempre que quero ver mais sobre Machine Learning e suas aplicações, acesso o Towards Data Science. Esse site é como se fosse uma bíblia para nós, por ter artigos valiosos das mais diversas tecnologias do universo de dados. Já salva nos favoritos (⭐️).

4) Datasets

Os datasets são o conjunto de dados que utilizaremos para treino e teste dos nossos modelos. É comum que eles estejam em formato .csv, separados principalmente por vírgulas, mas se seu problema é com classificação de imagens o formato será diferente.

Ponto importante: não considere que o dataset chegará perfeito para você (😅).

O que quero dizer aqui é que os dados podem vir com várias anomalias da fonte. Podem estar com um tipo de separador numa parte do documento e com outro tipo em outra, podem estar com campos faltantes que são cruciais para o modelo, ou você pode precisar obter um outro dado a partir dos que foram recebidos por ser uma variável importante. Nesse último caso entra o feature engineering que comentei no início do artigo.

Alguns dos pontos que precisa-se ter atenção quanto a datasets são:

• Quantidade insuficiente de dados. Reconhecimento de padrões em imagens, por exemplo, demandam milhões de exemplos.
• Número de casos observados equilibrado. Imagine que você tem um sistema que distinguirá sentimentos positivos de negativos. Se você tiver 9 linhas do dataset com exemplos de sentimentos positivos e apenas 1 linha com um sentimento negativo, você estará enviesando seu modelo a ter um output positivo, devido à quantidade maior de exemplos positivos que o treinou.
• Qualidade ruim dos dados. Exemplos são dados cheios de caracteres insignificantes, vários espaços em branco, e outros tipos de ruído que interferem no reconhecimento de padrões do modelo.

Datasets públicos podem ser encontrados em:

📌 Datasets do Kaggle

📌 Pesquisa de datasets da Google

📌 Repositório do awesomedata no GitHub

E pesquisando por “public datasets” no Google! 🤓

📌 Eu tenho um repositório onde eu ensino um exemplo de pré-processamento de dados, algo que você terá que fazer com certa frequência em seu dataset num cenário real, aqui.

5) Estatística e probabilidade

Os modelos preditivos utilizam matemática e estatística em sua construção, e descobri isso após estudá-los e entender a fundo como funcionam. Dizer que não será necessário entender estatística e matemática é uma mentira, porque para entregar valor para um cliente e garantir que tudo funciona adequadamente, é importante saber como as coisas funcionam por baixo dos panos e os cálculos efetuados por trás do resultado das inferências.

Segue abaixo alguns dos tópicos importantes de estatística e matemática aplicada à ciência de dados que você irá se deparar em sua jornada:

• Cálculo
• Álgebra linear
• Cálculo das probabilidades
• Teoria dos grafos
• Distribuições
• Média, mediana e moda
• Inferência Bayesiana
• Amostragem
• Testes de hipótese
• Otimização linear

Agora, vamos dar uma pausa. E se você me disser que não conhece esse mundo de coisas aí de cima?

Não tem problema você não conhecer. De verdade! E pode parecer super difícil no início, tendo em mente que o ensino básico reforça na nossa mente desde cedo que pessoas que têm facilidade com matemática são brilhantes e, com isso, criam uma dificuldade sobre o tema na nossa mente e certo distanciamento.

Sugiro que você veja o problema primeiro, depois veja o algoritmo, entenda a teoria e depois vá para a prática da matemática dele. Querer entender todos os conceitos de uma vez pode te estressar um pouco, pois é bastante coisa e você não precisará de tudo em um primeiro projeto.

O importante aqui é saber fazer análises exploratórias encontrar correlações, entendendo o que é seu presente e será seu futuro através de dados do passado e do que os números mostram.

Locais que podem te ajudar:

📌 EstaTiDados

📌 3Blue1Brown

📌 Khan Academy

📌 Udacity

📌 edX

📌 MIT

📌 Deeplizard

6) Testes

Os testes dentro da área de ciências de dados são muito diferentes dos testes realizados em projetos de engenharia de software. São realmente diferentes. Isso porque nós estamos trabalhando com muita matemática e dados, que não são como os métodos das aplicações de software.

São várias métricas aqui. As métricas do modelo (garantindo o sucesso das predições e cálculos corretos), do negócio (problema que estamos trabalhando) e de engenharia (que garantem o funcionamento e desempenho).

Alguns exemplos de métricas (das várias existentes) são:

• Accuracy
• Precision
• Recall
• F1 Score
• Log Loss/Binary Crossentropy
• AUC (Area Under the ROC Curve)

Ah, se familiarize com a matriz de confusão também! Ela disponibiliza seus resultados em uma matriz e os divide em verdadeiros positivos, falsos negativos, falsos positivos e verdadeiros negativos.

7) Pipeline

Data Science constitui-se de um pipeline bem robusto. Vai desde a concepção do problema até a apresentação dos resultados e o acompanhamento e monitoramento do modelo em produção, como pode ser visto no exemplo abaixo proposto por Martin Fowler.

Por isso é importante ter um pensamento generalista de como todo o processo vai ocorrer. Mesmo que você opte por focar em alguma das subáreas apresentadas, acho pertinente que você saiba em qual ponto você está contribuindo na cadeia e saiba discutir formas de melhorar o processo como um todo.

Além disso, nós fazemos nossos experimentos em notebooks, como falamos mais acima, mas não são esses notebooks que irão para produção. Por isso, vale dar uma olhada em Flask e Django, que são frameworks muito utilizados para expor esses modelos e permitir que predições sejam efetuadas em ambientes reais, e Serverless.

Algumas perguntas que você deve se fazer nesse passo são:

• Como versionar os dados que são adicionados aos meus datasets de tempos em tempos?
• Como implantar Continuous Integration e Continuous Delivery no meu projeto?
• Como manter meus modelos escaláveis em produção?
• Como monitorar meu modelo e se, depois da implantação, os resultados dele estão sendo conforme o esperado?
• Como reproduzir a mesma performance que tive em ambiente de desenvolvimento, mas agora em ambiente de produção?
• Como entregar resultado sem preconceito (bias)?

Locais que podem te ajudar:

📌 Artigo sobre Continuous Delivery em ML, do Martin Fowler

📌 Docker

📌 Kubeflow

📌 Kubernetes

📌 Apresentação de ML.Ops, do Nubank

📌 Tensorflow Extended (TFX)

📌 Azure Machine Learning

📌 Google AI Platform Pipelines

📌 MLflow

📌 PyCaret

8) Portfólio

Para conquistar sua primeira posição nessa área que está em constante crescimento, minha dica é ter seus projetos adicionados ao GitHub, muito bem documentados e explicados (imaginando que você está explicando para um leigo), e, se tiver a oportunidade, um site!

📌 Um bom projeto para começar é o projeto Titanic, disponível no Kaggle. Um overview muito interessante dele pode ser visto no site sigmoidal.ai.

9) Data Visualization/Data Storytelling

Você fez a análise exploratória, elaborou algumas provas de conceito, colocou a mão na massa para limpar os dados e deixá-los na forma padrão para serem utilizados no modelo escolhido, fez os testes e tirou as métricas online e offline. É bastante história para contar, e na nossa mente está tudo muito claro e sabemos onde chegamos. E para contar essa história para os stakeholders/pessoas impactadas pelos resultados obtidos?

É de extrema importância o estudo do data storytelling, que é a arte de contar histórias através dos dados, e do data visualization, relacionado a como representamos os dados de forma clara e que seja autoexplicativo para o público.

Para que nosso objetivo, de mostrar o impacto de certas decisões e o resultado das hipóteses levantadas, seja alcançado, muitas variáveis estão no caminho.

• Escolha de quais informações serão representadas: a síntese e a priorização são skills importantíssimas de um(a) cientista de dados. Saber “enxugar” as informações e escolher as mais importantes são coisas fundamentais para não deixar o público confuso e conseguir transmitir a ideia de forma clara e precisa. É importante clareza e objetividade para responder perguntas.
• Escolha do melhor gráfico para representação das informações: qual tipo de gráfico faz sentido para mostrar o impacto que essa informação possui? Uma variável está muito mais avançada que o resto do grupo, será que um gráfico de pizza faz mais sentido do que um gráfico de barras? Vale a pena utilizar um gráfico de linhas para mostrar o avanço que um dado teve conforme os anos se passaram? Após escolhido o gráfico, as cores de cada vertente possuem contraste suficiente entre si possível de serem distinguidas?
• Escolha da ordem de representação das informações até a chegada ao resultado obtido: uma apresentação que não possui uma linha de raciocínio clara para representação dos dados é uma apresentação perdida. A chave do sucesso para que a exibição dos resultados é engajamento, persuasão e coesão. O público precisa se engajar com os objetos presentes nas imagens, com o texto que é apresentado, com a forma com que os dados são comunicados — tanto pela pessoa que apresenta, quanto pelos atributos da apresentação falando, cada um por si (nem todas as pessoas que verão os resultados entenderão as palavras técnicas ditas — nivelar). A apresentação precisa ser persuasiva, defendendo um ponto de vista com base em informações que mostram embasamento teórico e garantem que o output seja fruto de grande estudo e exploração. Por fim, a coesão, que afirma que tudo tem início, meio e fim, tudo se encaixa de alguma forma e a mensagem final é entregue de forma igual para todas as pessoas.

Ter essas—entre diversas outras — capacidades de contar histórias é uma das coisas que o economista-chefe da Google, Dr. Hal R. Varian, considera que serão mais importantes para as próximas décadas.

“The ability to take data — to be able to understand it, to process it, to extract value from it, to visualize it, to communicate it — that’s going to be a hugely important skill in the next decades.” — Dr. Hal R. Varian (Economista Chefe da Google)

Bibliotecas úteis para visualização de gráficos:

📌 Matplotlib

📌 Seaborn

📌 Plotly

10) Metodologias

Uma metodologia é uma estratégia utilizada para orientar processos e atividades dentro de um determinado domínio. Exemplos de metodologias ágeis de software são Scrum, Kanban e XP.

A ciência de dados também fez suas contribuições para metodologias de gerenciamento de projetos, e não são tantas pessoas que possuem conhecimento dessa informação.

Abaixo estão listadas algumas dessas metodologias que você pode utilizar em seus projetos de ciência de dados, além das mais populares:

• CRISP-DM
• SEMMA
• KDD

📌 Nesse link você pode conferir uma live onde eu e Laura Damaceno abordamos essas metologias e damos exemplo de como utilizá-las em um projeto de ciência de dados na prática.

11) Comunicação

Soft skills são importantíssimas em qualquer área e costumam pesar ainda mais em tecnologia. Você sendo uma pessoa desenvolvedora de software que se comunica e sabe exemplificar suas ideias de maneira simples e objetiva, engajando a pessoa com quem fala, consegue conquistar espaços que ninguém mais conseguiria.

Por conta disso, é de extrema importância focar em como você comunica suas ideias, saber dialogar e reforçar seus pontos de vista e traduzir todo aquele contexto técnico que eu e você sabemos da complexidade para pessoas leigas que, muitas vezes, não estão interessadas em saber como você chegou até lá — querem saber se você chegou ou não.

12) Networking/Personal Branding

Nesse passo, quero reforçar a parte de como você se posiciona para as outras pessoas. Tenho uma live que pode te auxiliar a entender mais sobre o tema e sobre sua importância aqui.

É importante você, desenvolvedor ou desenvolvedora, saber mostrar o que possui de melhor e se vender com confiança e amor próprio. Saber vender suas ideias, projetos, tudo o que conquistou até chegar aqui e demonstrar que está preparado(a) para os desafios que vão vir.

Networking anda lado a lado com Personal Branding. Ter uma rede de contatos pode te ajudar a conseguir oportunidades fantásticas e iniciar na área de ciência de dados que você tanto sonhou com apenas um clique, adicionando a pessoa certa. Um exemplo simples disso é claro: imagine que, em meu LinkedIn, eu adicione uma pessoa que trabalha na empresa que eu sempre desejei pertencer. Essa pessoa pode curtir um post que fiz sobre ciência de dados e alguém da rede dessa pessoa pode ver que essa pessoa curtiu meu post e notar o meu engajamento com o assunto, e assim sucessivamente, até que a oportunidade chega!

Redes de contatos são importantíssimas no mercado e na vida. Use-as a seu favor!

13) Comunidades

As comunidades de tecnologia são ótimas para quem quer iniciar em qualquer ramo. Elas são uma fonte de networking e te abraçam com conteúdos gratuitos e pessoas dispostas a te ajudar sem pedir nada em troca. Recomendo fortemente que você ingresse em alguma delas e se apresente, mostrando o quanto quer aprender e contribuir!

Algumas comunidades são:

📌 WoMakersCode

📌 DataHackers

📌 AI Brasil

📌 Nubank Data Science & Machine Learning

📌 DataQuest

📌 Watson Developer Community

📌 Google Developer Group

📌 AI Girls

📌 Nerdzão

📌 Developers-BR

📌 School of AI

14) Inglês

Último, mas não menos importante: o inglês.

Eu não diria que o inglês é necessário, mas que é um grande bônus na maioria das vagas. Se você não se sente confortável com seu nível de inglês até o momento, acho super vantajoso que você procure aprimorá-lo com cursos com professores particulares ou com aplicativos gratuitos, como Duolingo.

Além de te ajudar em vagas, ele vai te ajudar depois que você entrar na empresa. A maioria dos conteúdos que consumo de ciência de dados estão em inglês — isso inclui artigos, cursos, datasets, ferramentas de trabalho, fóruns, etc. Isso acontece porque sempre quando sai algo novo na área, a primeira linguagem que você encontra é em inglês. Tendo isso em vista, você só tem a ganhar reforçando seu aprendizado na língua, e no YouTube tem muita coisa gratuita!

Retomando as expectativas

Vai com calma, again!

É uma área que nunca para, e nunca vai parar. Se você estiver parado, é porque tem algo errado.

Aproveite a jornada de aprendizado. Não desanime, não é fácil mas valerá a pena! Taca-lhe pau nesse carrinho!

➡️ Agradecimento especial à Ana Carolina, Gabriel Giro e Lucas Marques, que me ajudaram na revisão desse texto e estão sempre me apoiando. Admiro vocês do fundo do meu coração! ❤

➡️ Todas as imagens utilizadas neste artigo estão com suas devidas fontes e textos alt visando acessibilidade. Caso encontre algo que pode tornar esse texto ainda mais inclusivo, por favor, marque no texto e serei grata!

➡️ O artigo será sempre atualizado com novas informações e materiais, para sempre trazer o que há de mais novo para você.

Essa é a segunda parte de uma sequência de artigos sobre melhores práticas para desenvolvimento de chatbots.

Nela, estou abordando as melhores práticas para desenvolvimento dos assistentes que estão auxiliando as organizações em tarefas cotidianas e que necessitem de grande armazenamento de informação, podendo encontrar rapidamente os dados que precisam.

Se você não viu a primeira parte, dê uma olhada nela primeiro antes de prosseguir com a leitura!

Textos pequenos

A construção do diálogo é uma das partes mais importantes de um chatbot. Um chatbot precisa ser direto e comunicar de forma clara as informações necessárias.

Parágrafos grandes de texto complicam a experiência do usuário, e o faz perder a vontade de conversar com o assistente.

Se você tem muito para escrever, divida isso em diferentes blocos, de modo que o usuário tenha a impressão de que são diferentes interações que o bot está tendo com o chat.

Seja claro quando o bot não entender

Se o bot não entender alguma intenção dita na conversa, o ideal é que ele diga isso. Diga que o conteúdo informado não pode ser entendido, de forma que a pessoa possa tentar com outras palavras, deixando mais claro o que deseja.

Chamar um humano também é uma das opções. Muitas vezes o usuário irá preferir conversar com um dos atendentes disponíveis, e suas escolhas devem ter prioridade. Informe que a conversa será tocada por outra pessoa, e deixe o usuário à par de tudo que acontece. Feedbacks são importantíssimos e evitam falhas na comunicação.

O importante é responder todas as mensagens enviadas.

Não teste com a equipe que construiu

O ideal para que se possa realizar um efetivo teste com o chatbot é que a equipe que efetuará os testes seja diferente da que o desenvolveu. Os responsáveis por sua construção já possuem o conhecimento de toda a plataforma e podem, dessa forma, restringirem seus testes a determinados pontos e deixarem pontos importantes passarem despercebidos.

Pessoas que não tiveram contato prévio com o produto possuem um olhar amplo e de principiante, podendo enxergar coisas que não foram vistas antes.

Não faça perguntas abertas — dê opções claras

É comum enviarmos um e-mail ou escrevermos uma mensagem de texto e aquilo ser compreendido de uma forma totalmente diferente. Se nossa comunicação humano — humano já gera ruídos, imagina com um robô?

É importante que deixemos claras as informações que desejamos passar para o usuário durante a montagem do fluxo. Entendimentos errados pelo usuário pode gerar grandes problemas e fazer com que a aceitação ao bot seja algo muito difícil pelos usuários.

Quando falamos disso, é válido dar sugestões de resposta no estilo dos famosos “comandos” para que o usuário possa ter um norte do que é esperado dele como resposta para aquela pergunta.

Fluxo de interação

Quando trabalhamos com chatbots, temos contato com fluxos previstos e fluxos imprevistos.

Os fluxos imprevistos podem ser notados quando fazemos alguma pergunta do tipo “como posso te ajudar hoje?”. Essa pergunta é genérica, e abre portas para qualquer tipo de resposta possível. É necessário, ao seguir por esse caminho, traçar um roteiro de possíveis sugestões para o usuário para que ele possa ser guiado para uma solução que o bot consiga resolver.

Um exemplo é se o chatbot é sobre uma loja de roupas e o usuário digita que precisa de ajuda com um tempero para churrasco — o bot pode amigavelmente dizer “hmmm, não entendo sobre temperos para churrasco, mas entendo sobre qual a melhor roupa para uma festa de formatura! Vamos falar sobre isso?”. Isso faz com que a pessoa seja reforçada sobre o propósito e os limites daquele chatbot, e o fluxo passe a ser previsto — saberemos o que deve ser falado sobre o tópico pois o fluxo sobre roupas para festa de formatura é algo que o chatbot espera falar sobre.

Além disso, os chatbots devem facilitar as coisas. O usuário deve, com o mínimo de ações, conseguir realizar o que almeja.

Lembre-se de informações já fornecidas

Não se pode, em hipótese alguma, esquecer a informação que o usuário já passou. É como se você tivesse acabado de perguntar o nome de uma pessoa e falasse um minuto depois “qual seu nome?” novamente. Isso acarretará numa perda de engajamento gigantesca, fazendo com que o usuário se irrite e venha a interromper o uso do assistente por precisar repetir sua fala.

A situação do exemplo acima poderia ter sido contornada com “você ainda quer saber sobre a região de São Francisco, ou outra região?”. Dessa forma, a pessoa iria ficar feliz por saber que o bot “se lembrou” de sua última interação.

Seja humanizado, não repetindo as mesmas frases e trocando pequenas palavras

Utilize mensagens de erro diversificadas. Mensagens de erro com o mesmo padrão deixam o usuário desconfortável e removem a credibilidade do chatbot.

Questionários

Sabemos que, se seu chatbot deve fechar uma viagem para o usuário, ele terá um mínimo de informações para perguntar:

• Destino
• Horário de partida
• Horário de chegada
• Se a viagem for para ela, quantos acompanhantes, e se não for, quantas pessoas estarão envolvidas
• Que tipo de hospedagem a pessoa prefere
• Passeios que serão realizados

São várias perguntas, não?! Agora imagine o chatbot perguntando isso tudo de uma vez, que tumulto.

A primeira coisa que precisamos ter atenção é quanto à ordem de execução das ações. O ideal é que a sequência de perguntas ao usuário seja feita exatamente igual à realidade. Ficaria estranho, por exemplo, se perguntássemos primeiro para o usuário quantos passeios seriam realizados, e depois perguntássemos para onde ele está indo.

Portanto, é importante ter atenção em duas coisas: dividir as ações em pequenas perguntas e ordenar as perguntas de forma lógica.

Entendimento de metáforas

Quando enviamos para o bot “quero comprar uma fruta”, temos de forma clara quais são as intenções da frase e seu objeto. E se mandarmos “você fala como uma parede”?

Nem tudo o que não possui palavrões ou palavras negativas é positivo. Analisando palavra por palavra, não se encontra nada ofensivo na frase de exemplo acima. O problema é que nós, seres humanos, sabemos que paredes não falam. Portanto, a pessoa tem o intuito de dizer que o bot não está falando muito e a conotação da frase é totalmente negativa.

É importante que o chatbot entenda figuras de linguagem e compreenda as palavras em diferentes contextos, sabendo entender o papel das ironias e metáforas e direcionando a conversa para outro patamar ao perceber que a conversa toma tom negativo.

Essa foi a segunda parte da série. 😄

Ainda não acabou! Tem mais um artigo chegando! 🔥

Gostou? Deixa uma palminha para eu saber que esse artigo contribuiu em algo para você!

Melhores práticas para desenvolvimento de chatbots — Parte 2 was originally published in Bots Brasil on Medium, where people are continuing the conversation by highlighting and responding to this story.

Que os chatbots ganharam um espaço gigantesco no mercado, não podemos negar. Vemos várias organizações começarem a utilizar a tecnologia para entregar aos seus clientes um serviço rápido e que consiga, ao mesmo tempo, respondê-lo de forma amigável e sanar suas dúvidas prontamente.

Os chatbots, além de possuírem disponibilidade 24/7, podem aguentar um grande número de usuários, responder perguntas repetitivas e tornar automáticas tarefas rotineiras. Isso permite que o tempo, que antes era gasto em algo mecânico, seja investido em algo que possa agregar ainda mais valor e seja motivador/estimule a criatividade.

Por ser algo relativamente novo no mercado, algumas pessoas possuem certas dúvidas de como estruturar, montar um planejamento e, até mesmo, iniciar um projeto de chatbot de sucesso e que satisfaça as expectativas estipuladas.

Com essa sequência de artigos, quero clarificar alguns passos no desenvolvimento de chatbots em organizações, a fim de facilitar a implantação dessa tecnologia que, em muito, pode auxiliar nosso dia a dia e trazer grande valor para o negócio.

Antes de partir para a técnica, vamos conversar sobre algumas coisas…

Escopo definido

Durante o planejamento do ingest (adição de dado e conteúdo) no chatbot, é de extrema importância que se defina qual será o escopo em cima do qual o chatbot trabalhará. Isso faz com que possamos ter uma noção maior de seu desempenho e possamos concluir etapas, não perdendo a noção do quanto ele abrange e podendo definir de forma clara seu domínio.

Squad especialista

O ideal para se ter um chatbot que supere as expectativas dos clientes é que ele tenha sido construído por uma equipe multidisciplinar. Mesmo que a tecnologia seja um dos pontos chaves na construção, é importante que se tenha especialistas de montagem de fluxos conversacionais e responsáveis pela estratégia de escrita.

Um exemplo de squad seria, por exemplo (sem levar em consideração o tamanho da equipe, pois depende do ramo e do tamanho do projeto):

• Product Owner (repassará a visão do cliente e possuirá em mente o roadmap e a visão do produto)
• Arquiteto da tecnologia
• Desenvolvedor de chatbot
• Arquiteto de conversação
• Designer de conversação
• Copywriter

Isso porque não estamos falando ainda de um chatbot voltado para voz. Nesse caso, temos novos profissionais a serem adicionados, como o VUI Designer.

Personalidade

Criar uma persona para seu bot faz com que os usuários que interagem com o mesmo possam criar uma maior sintonia, gerando maior engajamento e fazendo com que as pessoas se interessem em continuar conversando com o assistente.

A criação da persona é uma das partes mais importantes no projeto de chatbot. Dentro desse processo, alguns tópicos podem ser importantes para nortear essa criação:

• Quais são as características do seu público? Baby boomers, millenials, os dois, ou algo totalmente diferente? Este mapeamento é importantíssimo para definir como seu bot deve se relacionar.
• Como seria sua marca se ela fosse uma pessoa? Quando pensamos no contexto de chatbots, é muito comum que foquemos como uma pessoa que possa atender alguma solicitação. No entanto, o assistente não precisa, necessariamente, ser um humano. As opções são inimagináveis: animais, objetos, plantas, ou até mesmo seres fictícios que representem seu negócio.
• Como sua marca falaria pessoalmente com seu público? Ela é uma marca que preza a positividade? Algo mais corporativo?
• Qual a principal função do seu chatbot? Ajudar a marcar viagens, procurando passagens aéreas? Ou auxiliar com despesas financeiras? Isso irá marcar como será a forma com que ele tratará o usuário e seu engajamento com o público.

Vamos colocar a mão na massa?

Pense como o usuário na formulação das perguntas

Dificilmente os usuários irão fazer perguntas extremamente estruturadas, como em uma faq. O mais provável é que eles usem uma linguagem extremamente coloquial, com possíveis abreviações e gírias. Eles irão falar com o chatbot de forma direta e, muitas vezes, deixar em aberto o que desejam.

No momento do treinamento, é de extrema importância que pensemos como um usuário (aí está o poder da empatia): imagine que ele está em uma correria enorme, sem tempo para escrever de maneira formal. Deve-se treinar o bot e verificar seu desempenho com o tipo de escrita que seu nicho de usuário possui, evitando que haja falhas na comunicação e o bot não entenda quase todas as mensagens enviadas.

Apresente-se e diga qual seu papel!

É importante que o usuário saiba qual o propósito do chatbot antes de iniciar a conversa. Isso fará com que ele possa ter uma conversa mais focada dentro dos objetivos estabelecidos, e não acabe por desestruturar o fluxo do chatbot devido à expectativas diferenciadas do que o mesmo faz.

São diversas as formas de apresentação possíveis. Em uma simples frase, você pode informar qual é o propósito do chatbot e o motivo pelo qual ele pode ser útil para o usuário.

Feito é melhor que perfeito

Montar fluxos grandes demais fará com que se gaste muito tempo com a criação de diálogos complexos na tentativa de tapar todos os buracos, sendo que na primeira conversa com uma pessoa externa, já serão encontrados no mínimo 5 buracos que estavam escondidos.

Com isso em mente, é interessante que o aprendizado do assistente seja planejado em etapas. Desejar que o mesmo seja especialista em um determinado assunto da noite para o dia é inviável e desgastante. Fazer com que ele domine pequenas partes de um contexto de forma gradativa é muito mais simples e fácil de obter métricas e validar seu conhecimento nos tópicos a ele atribuídos.

Outro ponto importante é que, desenvolvendo-se o chatbot por etapas, podemos validá-lo com os clientes mais rapidamente e verificar se o “mvp” satisfaz as condições estipuladas inicialmente.

Forneça sugestões, mas permita a digitação

Sabemos que há dois tipos de chatbots — os compostos por comandos e os de linguagem natural.

O chatbot por comandos possui uma série de instruções predefinidas para o usuário escolher, não sendo possível a escolha de funções diferentes das listadas.

Isso faz com que os usuários fiquem limitados quanto a opção de escolha, e não torne a experiência tão humanizada — embora ainda sejam muito úteis dependendo do contexto a ser trabalhado.

Ao trabalharmos com chatbots de linguagem natural, trazemos uma aproximação ainda maior com a nossa realidade. Temos a liberdade de enviar mensagens semelhantes às que enviamos para amigos e colegas em aplicativos de mensageria já existentes, tornando a experiência muito avançada.

É possível mixar ambas as funcionalidades. Trazer para o chatbot de comandos uma caixa de digitação que permita ao usuário dizer o que deseja, caso as opções que lhe foram fornecidas não o satisfaçam, ou o contrário — trazer para o chatbot de linguagem natural alguns comandos predefinidos que facilitem a conversação.

O que é importante, nos dia de hoje, é a pessoa possuir liberdade e agilidade.

Tá achando que acabou? Ihhhhh, achou errado, acabou não! 😄

A sequência continua! Tem mais dois artigos chegando! Está só começando! 🔥

Gostou? Deixa uma palminha para eu saber que esse artigo contribuiu em algo para você!

Melhores práticas para desenvolvimento de chatbots — Parte 1 was originally published in Bots Brasil on Medium, where people are continuing the conversation by highlighting and responding to this story.

Eu sempre ouvi falar da Campus Party. As referências eram de um evento voltado para todo e qualquer assunto relacionado à tecnologia e inovação. Sempre tive a curiosidade de saber como era e poder falar sobre o evento com aquela alegria contagiante com que todo mundo falava.

Em fevereiro deste ano, através do Womakerscode - Tecnologia, Carreira e Protagonismo, tive a oportunidade de ir até o evento pela primeira vez.

O evento ocorreu no Expo Center Norte, que conseguiu comportar bem o número grande de pessoas que compareceram.

O dia que consegui comparecer foi 16/02 (sábado), um dia antes da finalização do evento que perdurou de 12/02 (terça-feira) até 17/02 (domingo).

O evento estava bem cheio, e desde o início me propus a gravar e mostrar para todos o que mais de inovador havia em forma de vídeo, que posteriormente seria postado no meu canal do YouTube.

Ônibus

Um ponto que achei bem interessante é que há um ônibus que leva os participantes do Terminal Rodoviário Tietê para o local do evento. Isso foi ótimo para mim, que moro em outra cidade e chego até São Paulo por este mesmo terminal. 🤗

Eu demorei um pouco para localizar o ponto onde os ônibus estavam situados. Tive que procurar bastante para encontrar e perguntar para muitas pessoas, e quase nenhuma sabia me informar. Talvez seja interessante adicionar algumas fotos do ponto no próprio site no próximo evento, pois o terminal é grande e pode facilitar o encontro dos participantes.

Ingressos

Um dos pontos que, ao meu ver, faz parte dos mais interessantes.

O meu ingresso era do tipo Camping, ou seja, eu tinha direito de acampar no evento todos os dias. No entanto, meu namorado só pode ir um dia comigo. O site da Campus não oferecia nenhum tipo de ingresso day pass, onde a pessoa poderia usufruir de apenas um dia do evento.

Quando eu estava quase perdendo as esperanças, vi o seguinte banner, que fez meus olhos brilharem:

Caso a pessoa interessada em passar um dia na Campus tivesse algum eletrônico que pudesse ser doado ou precisasse ser descartado, ela poderia fazer a troca do mesmo (seguindo as condições acima descritas) por um ingresso para um dia. Era o que precisávamos!

Após efetuarmos a troca, seguimos para a entrada do evento.

Open Campus

Uma das coisas que me chamou a atenção foi uma área chamada Open Campus, onde não é necessário o ingresso para visita. Nessa área haviam algumas atrações interessantes que envolviam realidade virtual e algumas talks, que puderam envolver pessoas que estavam de passagem pelo evento mas não possuíam o ingresso.

Passando a Open Campus, temos acesso à Campus Arena, que é a área paga do evento.

Nessa área, nós temos acesso à maioria das palestras que acontecem e aos stands, workshops e hackatons. Elas acontecem a todo momento, sendo cerca de 300 horas de conteúdo.

Camping

Assim que cheguei, procurei ver como funcionava a área do camping. Sabia que havia um processo de retirada de barraca e montagem dela, então procurei fazer isso o quanto antes para poder separar o restante do dia para aproveitar o evento.

A quantidade de barracas é absurda! Como o evento recepciona pessoas de todo o país e tem duração de quase uma semana, o espaço é bem grande para abrigar tamanho número de pessoas.

Há duchas e espaço dedicado para os campuseiros que acampam, contendo uma padaria para os mesmos. Uma pena que eu não tenha conseguido usufruir melhor desse espaço por ter ficado apenas um dia. 🙁

Após montar minha barraca, finalmente entrei na Arena e iniciei os trabalhos de conhecer a Campus.

Programação

Uma dica que eu dou a todas as pessoas que irão no evento — e não apenas nesse evento, mas em qualquer um que você venha a comparecer — é baixe o aplicativo/paper da programação. Isso é importantíssimo para que você consiga aproveitar ao máximo o evento, tornando seus dias mais produtivos e permitindo que você consiga extrair o máximo de conteúdo!

Baixei o aplicativo da Campus e tive ideia de como me preparar, selecionando as palestras que eu desejava ir logo no início do evento. É possível filtrar por dia, por palestrante, por palco…

São vários palcos! Palco Startups, STEAM, Feel the Future (um dos mais amados), Creativity/Design, Entertainment, Coders, Entrepreneurship, Makers, Academia Creators, Academia Gamers, e mais workshops e comunidades de montão!

Ecossistema

Muitos participantes levam seus computadores customizados (vários com upgrades, leds, configurações altíssimas e hardware de ponta) para exibir no evento ou para jogar com outros participantes. Há vários campeonatos que ocorrem paralelamente às palestras.

A maioria das atrações girava em torno de realidade virtual, com a utilização de óculos rift e sensores de movimento. Experimentei algumas, mas outras não consegui devido às filas enormes.

Enquanto passeava pelo evento, vi uma galera jogando o Beat Saber, e super me interessei em conhecer.

No vídeo do YouTube onde registrei tudo (está no final do artigo para você ver!), coloquei por que achei esse jogo perigoso. Assista! 😅

Tinha até um espacinho do Sesc para quem quisesse dar uma relaxada.

Palestras

As palestras que assisti foram ótimas! Foi um pouco corrido, então consegui priorizar 4 dentro do escopo imenso que tinha.

Rodrigo Galvão, em Feel the Future, com “O que brilha seus olhos? Rodrigo Galvão, de estagiário a presidente!”

Thiago Melo, em Entrepreneurship, com “Pense como um Product Manager desde o dia Zero”

Juliana Munaro, em Entrepreneurship, com “Empreender: quais são os desafios?”

Cynthia Zanoni, em Coders, com “PWA — o futuro dos aplicativos Mobile Web”

Tenho duas entrevistas que ainda serão postadas, com o Thiago e com a Juliana. Nas próximas semanas irei divulgar!

Para a organização

Eu achei muito interessante a ideia de deixar que os participantes que optaram pela opção do camping possam levar suas barracas embora. Eu não tinha uma barraca, e achei massa poder levar a minha para casa.

No entanto, ao invés de usar minha barraca para um momento de lazer próprio, tive uma ideia junto com a minha mãe de dar uma utilidade melhor para ela. Doar a minha barraca a algum morador de rua ou pessoa que precisasse de um abrigo.

Doação de barracas não usadas

Quando estava indo embora do evento, notei uma grande quantidade de barracas que não haviam nem sido montadas. Se contarmos essas e as que serão deixadas para trás por participantes que não desejam levar consigo suas barracas, teremos aí um número gigantesco de barracas que podem ser doadas a quem precisa.

Há um número muito grande de desabrigados que passam frio por não terem um lar. Considerando isso e as chuvas constantes a que estamos dispostos ultimamente, a doação dessas barracas que foram deixadas seria uma ótima solução para esse problema — ou, ao menos, um começo para isso.

Não sei o que é feito com as barracas que sobram. Caso já tenha algum tipo de destino para as mesmas que beneficie alguém no final, essa sugestão pode ser desconsiderada. No entanto, acho que seria uma corrente muito bacana que poderia ser seguida a todos que pudessem fazer o mesmo.

TV’s maiores para os workshops

Enquanto eu passeava pela Campus, prestei atenção em alguns workshops e vi que havia uma grande quantidade de pessoas para assistirem uma TV bem pequena, onde eram projetados os slides dos palestrantes.

Se o número de pessoas já era grande, eu imagino o quão maior seria se as TV’s fossem ainda maiores. Seria muito mais receptivo para um público maior aproveitar o conteúdo! 😄

A Campus, além de um lugar ótimo para obtenção de conhecimento, é favorável para networking. Encontrei pessoas lindas por lá, que conhecia já nas redes e em alguns eventos, e poder fortalecer esses laços é algo enriquecedor!

#CPBR12, eu fui! ✌️

Um agradecimento especial à Womakerscode - Tecnologia, Carreira e Protagonismo e à Cynthia Zanoni por afirmarem com excelência o espaço da mulher, não só na tecnologia, mas em todas as vertentes do mundo de luta em que vivemos.

O vídeo que gravei é esse aqui ⬇️

Me conte o que achou e me fale das suas impressões sobre a Campus Party também! ❤

Minha primeira vez na Campus Party was originally published in Blog Mikaeri Ohana on Medium, where people are continuing the conversation by highlighting and responding to this story.