OCI AI FOUNDATIONS ASSOCIATE: Inteligência Artificial e Machine Learning no Oracle Cloud

A OCI AI Foundations é uma prova com personalidade dupla. Metade da prova trata dos conceitos gerais de Inteligência Artificial e Machine Learning e a outra metade foca no portfólio específico de produtos relacionados a IA da Oracle. O objetivo é que você saiba o suficiente da teoria para entender o que cada serviço faz por baixo dos panos e que saiba o suficiente de cada produto de IA da Oracle para escolher o serviço certo na hora de resolver um problema.

Das três certificações Foundations, essa é, sem dúvida, a que você vai sentir o retorno mais imediato em seu trabalho. O portfólio de IA da Oracle cresceu de forma considerável nos últimos dois anos, e o trabalho dessa certificação é apresentar tudo o que existe à sua disposição. Afinal, tem muita gente construindo solução do zero quando já existe um serviço gerenciado para resolver aquele problema.

Dados da prova:

- Código: 1Z0-1122-25
- Questões: 60, múltipla escolha
- Duração: 60 minutos
- Aprovação: 65%
- Custo: gratuito
- Aposentadoria da versão 2025: 29 de maio de 2026

Parte 1 - O que é a área e o que a prova cobre

Inteligência Artificial é um termo muito amplo que engloba diversas tecnologias cada vez mais presentes em nosso cotidiano. Mas saber disso não é o suficiente para a certificação. Você deve entender algumas dessas diferentes áreas. Machine Learning, por exemplo, permite que um sistema aprenda padrões de dados sem codificação manual. Já Deep Learning vai um pouco além, funciona como um Machine Learning, mas usa redes neurais com muitas camadas. Generative AI é uma área do Deep Learning dedicada a produzir conteúdo original, seja textos, imagens, código, áudio ou vídeo.

A prova divide tudo isso em sete domínios. Os pesos aproximados ficam assim:

Domínio e Peso

OCI AI Portfolio                ~20%
OCI Generative AI e Oracle 23ai ~20%
Intro OCI AI Services           ~15%
Intro Generative AI e LLMs      ~15%
Intro ML Foundations            ~15%
Intro Deep Learning             ~15%
Intro AI Foundations            ~10%

Repare que os dois maiores pesos são produtos Oracle. Não é uma certificação de IA qualquer. Quem se prepara só com Coursera, livro de Machine Learning e podcast pode se sair bem nos primeiros 50%, mas vai patinar nos outros 50%. Estude o portfólio Oracle com calma - é ele que vai definir a sua aprovação.

O conteúdo de cada domínio, sem frescura:

AI Foundations - o que é IA, diferença entre IA estreita e geral, casos de uso reais, terminologia básica.

ML Foundations - aprendizado supervisionado (classificação e regressão), não supervisionado (clustering, redução de dimensionalidade), reinforcement learning, overfitting, underfitting, divisão treino/teste/validação, métricas de avaliação.

Deep Learning - redes neurais artificiais, forward e backpropagation, funções de ativação, CNNs para visão, RNNs para sequências.

Generative AI e LLMs - Transformers, mecanismo de atenção, embeddings, tokenização, modelos de linguagem, tipos de prompt, fine-tuning, RAG.

OCI AI Portfolio - OCI Data Science, OCI Data Labeling, GPU Compute para treinamento.

OCI Generative AI e Oracle 23ai - OCI Generative AI Service (modelos disponíveis, endpoints, embeddings), Oracle Database 23ai com AI Vector Search, diferença entre vector search e RAG tradicional.

OCI AI Services - Vision, Language, Speech, Document Understanding, Anomaly Detection.

Parte 2 - Os serviços Oracle na prática

OCI Generative AI Service

O Generative AI Service é onde a Oracle entrega LLMs como API gerenciada. Você não precisa se preocupar com GPU, cluster ou deploy. Você manda a requisição, recebe a resposta. Os modelos disponíveis incluem a família Llama 4 da Meta (llama-4-scout, llama-4-maverick), Cohere Command A e Grok. Por conta da integração com o Google Vertex AI, o Gemini também fica acessível pelo mesmo lugar.

O serviço foca em três pilares: geração de texto (chat e completion), embeddings (transformar texto em vetor numérico para busca semântica) e fine-tuning (customizar o treinamento do modelo com seus dados para adaptá-lo a um comportamento esperado).

Um exemplo simples de chat:

[Python]
import oci

# Configuração do cliente
config = oci.config.from_file()
generative_ai_client = oci.generative_ai_inference.GenerativeAiInferenceClient(config)

# Chamada de chat
chat_request = oci.generative_ai_inference.models.CohereChatRequest()
chat_request.message = "Explique o que é RAG em duas frases"
chat_request.max_tokens = 200
chat_request.is_stream = False

chat_detail = oci.generative_ai_inference.models.ChatDetails()
chat_detail.compartment_id = "<compartment-ocid>"
chat_detail.serving_mode = oci.generative_ai_inference.models.OnDemandServingMode(
 model_id="cohere.command-a-03-2025"
)
chat_detail.chat_request = chat_request

response = generative_ai_client.chat(chat_detail)
print(response.data.chat_response.chat_history[-1].message)

Embeddings convertem texto em vetores numéricos. Textos que dizem coisas semelhantes ficam próximos no espaço vetorial, mesmo escritos com palavras totalmente diferentes. É a base da busca semântica.

[Python]
# Gerar embeddings para busca semântica
embed_text_detail = oci.generative_ai_inference.models.EmbedTextDetails()
embed_text_detail.compartment_id = "<compartment-ocid>"
embed_text_detail.inputs = [
 "Qual o prazo de entrega para São Paulo?",
 "Em quanto tempo chega meu pedido?",
 "Como funciona o frete expresso?"
]
embed_text_detail.serving_mode = oci.generative_ai_inference.models.OnDemandServingMode(
 model_id="cohere.embed-multilingual-v3.0"
)
embed_text_detail.input_type = "SEARCH_QUERY"

response = generative_ai_client.embed_text(embed_text_detail)
vectors = [item for item in response.data.embeddings]
# vectors[0] é um vetor de ~1024 dimensões para a primeira frase

Para o fine-tuning, a Oracle implementa o método T-Few, que atualiza só um subconjunto de parâmetros em vez do modelo inteiro. Mais rápido, mais barato, e suficiente para a maioria dos casos. Os dados de treino entram em formato JSONL armazenados no Object Storage.

Aqui vem uma pergunta importante: quando optar pelo fine-tuning e quando optar pelo RAG? RAG ganha quando seu conteúdo muda com frequência, assim você só atualiza a base de documentos sem mexer no modelo. Fine-tuning ganha quando você quer mudar o jeito do modelo falar (estilo, tom, terminologia específica do seu domínio) de forma permanente, ou quando o contexto relevante é grande demais para caber no prompt. As duas técnicas convivem bem: muita gente faz RAG por cima de um modelo levemente ajustado com o vocabulário necessário.

Oracle Database 23ai - AI Vector Search

A versão 23ai do Oracle Database adicionou algo que muda a forma de pensar em arquitetura de IA: um tipo de dado nativo chamado VECTOR e operações de similaridade rodando em SQL puro. Isso significa que você faz busca semântica direto no banco relacional, sem manter um vector store separado.

-- Criar tabela com coluna de embedding
CREATE TABLE documentos (
 id   NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
 titulo  VARCHAR2(500),
 conteudo CLOB,
 embedding VECTOR(1024, FLOAT32)
);

-- Inserir documento com embedding
INSERT INTO documentos (titulo, conteudo, embedding)
VALUES (
 'Política de devolução',
 'Produtos podem ser devolvidos em até 30 dias...',
 '[0.023, -0.156, 0.089, ...]'
);

-- Busca por similaridade: 3 documentos mais próximos de uma query
SELECT id, titulo,
VECTOR_DISTANCE(embedding, :query_vector, COSINE) AS distancia
FROM documentos
ORDER BY distancia
FETCH FIRST 3 ROWS ONLY;

-- Criar índice vetorial para acelerar a busca
CREATE VECTOR INDEX idx_doc_embedding
ON documentos (embedding)
ORGANIZATION INMEMORY NEIGHBOR GRAPH
DISTANCE COSINE
WITH TARGET ACCURACY 95;

A integração com o OCI Generative AI deixa você gerar embedding direto via SQL, usando o pacote DBMS_VECTOR_CHAIN:

[SQL]
DECLARE
 v_query_embedding VECTOR;
 v_query_text VARCHAR2(200) := 'Qual o prazo de devolução?';
BEGIN
 v_query_embedding := DBMS_VECTOR_CHAIN.UTL_TO_EMBEDDING(
v_query_text,
JSON('{"provider": "ocigenai",
  "credential_name": "OCI_CRED",
  "url": "https://inference.generativeai.sa-saopaulo-1.oci.oraclecloud.com/...",
  "model": "cohere.embed-multilingual-v3.0"}')
 );

 FOR doc IN (
SELECT titulo, VECTOR_DISTANCE(embedding, v_query_embedding, COSINE) AS dist
FROM documentos
ORDER BY dist
FETCH FIRST 3 ROWS ONLY
 ) LOOP
DBMS_OUTPUT.PUT_LINE(doc.titulo || ' - distância: ' || doc.dist);
 END LOOP;
END;

Aqui você ganha na arquitetura. Quem já tem Oracle Database não precisa subir Pinecone, Qdrant ou Weaviate paralelo. O Vector Search vive no mesmo banco onde seus dados relacionais já moram, com SQL padrão, as mesmas garantias ACID e o mesmo controle de acesso que você já configurou. Menos partes soltas, menos sincronização, menos coisas para quebrar de madrugada.

OCI Data Science

O OCI Data Science é o ambiente gerenciado para treinar, avaliar e colocar modelos em produção. Quem usa SageMaker da AWS vai reconhecer a estrutura. As partes centrais são:

- Notebook Sessions: JupyterLab gerenciado com shapes de compute prontos (incluindo GPU). Conda pré-instalado, bibliotecas populares já na caixa (scikit-learn, TensorFlow, PyTorch, XGBoost).

- Jobs: roda código Python de forma assíncrona, sem precisar manter notebook aberto. Útil para treino longo ou pré-processamento pesado.

- Model Catalog: registro central de modelos com versionamento e metadados.

- Model Deployment: endpoint REST de inferência com auto-scaling.

- Pipelines: orquestra as etapas de ML (pré-processamento, treino, avaliação, deploy) como um fluxo.

[Python]
import oci

data_science_client = oci.data_science.DataScienceClient(config)

job = oci.data_science.models.CreateJobDetails(
 project_id="<project-ocid>",
 compartment_id="<compartment-ocid>",
 display_name="treino-modelo-churn",
 job_configuration_details=oci.data_science.models.DefaultJobConfigurationDetails(
job_type="DEFAULT",
environment_variables={
 "LEARNING_RATE": "0.01",
 "EPOCHS": "100"
}
 ),
 job_infrastructure_configuration_details=oci.data_science.models.StandaloneJobInfrastructureConfigurationDetails(
job_infrastructure_type="STANDALONE",
shape_name="VM.Standard.E4.Flex",
shape_config_details=oci.data_science.models.JobShapeConfigDetails(
 ocpus=4,
 memory_in_gbs=32
),
subnet_id="<subnet-ocid>"
 )
)

job_response = data_science_client.create_job(job)
print(f"Job criado: {job_response.data.id}")

OCI AI Services pré-treinados

Aqui é onde a Oracle oferece tarefas mais comuns de IA prontas, sem necessidade de treinamento prévio. Você manda uma imagem, recebe objetos detectados. Manda um áudio, recebe a transcrição. Na prática, essas soluções dão conta da maioria dos casos. Treinar modelo próprio só faz sentido quando o domínio é muito específico e os pré-treinados estão perdidos.

OCI Vision - trabalha imagem. Detecta objetos, classifica cenas, extrai textos (OCR) e reconhece rostos.

[Python]
ai_vision_client = oci.ai_vision.AIServiceVisionClient(config)

analyze_image_details = oci.ai_vision.models.AnalyzeImageDetails(
 features=[
oci.ai_vision.models.ImageObjectDetectionFeature(
 feature_type="OBJECT_DETECTION",
 max_results=10
),
oci.ai_vision.models.ImageTextDetectionFeature(
 feature_type="TEXT_DETECTION"
)
 ],
 image=oci.ai_vision.models.InlineImageDetails(
source="INLINE",
data="<base64-encoded-image>"
 )
)

response = ai_vision_client.analyze_image(analyze_image_details)

for obj in response.data.image_objects:
 print(f"{obj.name}: {obj.confidence:.2%} de confiança")

for line in response.data.image_text.lines:
 print(f"Texto: {line.text}")

OCI Language - trabalha texto. Sentimento (positivo, negativo, neutro), detecção de idioma, extração de entidades (pessoa, organização, local, data), classificação, tradução. Funciona em português.

[Python]
ai_language_client = oci.ai_language.AIServiceLanguageClient(config)

sentiment_details = oci.ai_language.models.BatchDetectLanguageSentimentsDetails(
 documents=[
oci.ai_language.models.SentimentsDocument(
 key="doc1",
 text="O atendimento foi excelente e o produto chegou antes do prazo."
),
oci.ai_language.models.SentimentsDocument(
 key="doc2",
 text="Péssima experiência. O produto chegou quebrado e o suporte não respondeu."
)
 ]
)

response = ai_language_client.batch_detect_language_sentiments(sentiment_details)
for doc in response.data.documents:
 print(f"Doc {doc.key}: {doc.document_sentiment} ({doc.document_scores})")

OCI Speech - transcreve áudio para texto com timestamp por palavra. Use para transcrever reunião, gerar legenda, indexar conteúdo de áudio para busca.

[Python]
ai_speech_client = oci.ai_speech.AIServiceSpeechClient(config)

transcription_job = oci.ai_speech.models.CreateTranscriptionJobDetails(
 compartment_id="<compartment-ocid>",
 display_name="transcricao-reuniao-abril",
 model_details=oci.ai_speech.models.TranscriptionModelDetails(
domain="GENERIC",
language_code="pt-BR"
 ),
 input_location=oci.ai_speech.models.ObjectListFileInputLocation(
location_type="OBJECT_LIST_FILE_INPUT_LOCATION",
object_location=oci.ai_speech.models.ObjectLocation(
 namespace_name="<namespace>",
 bucket_name="audio-reunioes",
 object_names=["reuniao-2026-04-15.mp3"]
)
 ),
 output_location=oci.ai_speech.models.OutputLocation(
namespace_name="<namespace>",
bucket_name="transcricoes",
prefix="2026/04/"
 )
)

response = ai_speech_client.create_transcription_job(transcription_job)

OCI Document Understanding - vai além do OCR. Reconhece a estrutura do documento, lê tabelas mantendo a estrutura, classifica o tipo de documento (nota fiscal, contrato, formulário) e extrai campos pelo significado, não pela posição.

[Python]
ai_document_client = oci.ai_document.AIServiceDocumentClient(config)

analyze_document_details = oci.ai_document.models.AnalyzeDocumentDetails(
 features=[
oci.ai_document.models.DocumentTableExtractionFeature(
 feature_type="TABLE_EXTRACTION"
),
oci.ai_document.models.DocumentKeyValueExtractionFeature(
 feature_type="KEY_VALUE_EXTRACTION"
),
oci.ai_document.models.DocumentClassificationFeature(
 feature_type="DOCUMENT_CLASSIFICATION"
)
 ],
 document=oci.ai_document.models.InlineDocumentDetails(
source="INLINE",
data="<base64-encoded-pdf>"
 )
)

response = ai_document_client.analyze_document(analyze_document_details)
print(f"Tipo: {response.data.detected_document_types[0].document_type}")

for kv in response.data.pages[0].key_value_fields:
 print(f"{kv.field_label.name}: {kv.field_value.text}")

OCI Anomaly Detection - pega série temporal multivariada e identifica anomalias. Treina com dados históricos normais e depois monitora em tempo real ou em batch. Funciona bem para falha de equipamento, fraude em transação ou métrica de sistema saindo do padrão.

[Python]
anomaly_client = oci.ai_anomaly_detection.AnomalyDetectionClient(config)

detect_anomaly_details = oci.ai_anomaly_detection.models.DetectAnomaliesDetails(
 model_id="<model-ocid>",
 request_type="INLINE",
 inline_request_details=oci.ai_anomaly_detection.models.InlineDetectAnomaliesRequest(
request_type="INLINE",
data_items=[
 oci.ai_anomaly_detection.models.DataItem(
  timestamp=datetime(2026, 4, 15, 14, 30, 0),
  values=[72.5, 45.2, 0.89]
 ),
 oci.ai_anomaly_detection.models.DataItem(
  timestamp=datetime(2026, 4, 15, 14, 32, 0),
  values=[89.7, 78.3, 1.45] # pico anormal
 )
]
 )
)

response = anomaly_client.detect_anomalies(detect_anomaly_details)
for anomaly in response.data.anomalies:
 print(f"Timestamp: {anomaly.timestamp} | Score: {anomaly.anomaly_score:.3f}")

OCI Data Labeling

Antes de treinar um modelo customizado, alguém precisa tratar os dados. É aí que entra o OCI Data Labeling. Você cria o dataset, importa imagens ou textos diretamente do Object Storage e distribui a anotação para o time via interface web.

Para imagem: bounding box para detecção de objeto, classificação por rótulo, segmentação. Para texto: classificação ou reconhecimento de entidade nomeada.

Conceitos de ML que caem na prova

A prova não pede para você implementar algoritmo, mas espera que você reconheça os conceitos e saiba aplicá-los a cenários reais. Os mais importantes:

Overfitting acontece quando o modelo aprende os dados de treino bem demais e perde a capacidade de generalizar. Bate acurácia alta no treino e performa mal nos testes. Soluções comuns: mais dados, regularização, dropout, early stopping.

Underfitting é o oposto: o modelo é simples demais para os padrões dos dados. Bate acurácia ruim em todo lugar. Soluções: modelo mais complexo, mais features, mais tempo de treino.

Métricas para classificação:

- Accuracy: percentual de acerto. Engana quando as classes estão desbalanceadas.

- Precision: dos casos que o modelo disse "positivo", quantos eram mesmo? Importa quando falso positivo é um problema.

- Recall: dos casos que eram positivos, quantos o modelo achou? Importa quando falso negativo é o problema.

- F1 Score: média harmônica entre Precision e Recall. Bom indicador quando você quer equilíbrio.

RAG vs Fine-tuning é quase certeza que vai estar na prova. RAG busca documentos relevantes numa base externa e inclui no contexto do prompt antes de gerar a resposta. Ótimo quando os dados mudam constantemente. Fine-tuning re-treina o modelo para incorporar o conhecimento nos pesos. Bom para adaptar estilo, tom e terminologia de domínio.

Normalmente isso aparece com um cenário real: "empresa tem base de conhecimento de suporte que muda mensalmente, qual abordagem usar?". Resposta: RAG. Atualizar documento é barato, treinar modelo todo mês é caro e demorado.

Transformers e atenção são o coração dos LLMs modernos. O mecanismo de atenção calcula, para cada token, o quanto cada outro token na sequência deve importar. Pega a frase "O banco estava cheio de peixes": quando o modelo processa "banco", a atenção pesa "peixes" e "cheio" mais que "agência" ou "dinheiro". Esse mecanismo é o que permite contexto longo funcionar de verdade.

Embeddings são representações numéricas de texto em espaço de muitas dimensões, onde proximidade geométrica corresponde a proximidade de significado. "Cão", "cachorro" e "dog" ficam perto, mesmo sendo strings totalmente diferentes. É a base da busca semântica.

Parte 3 - O curso online e o ritmo de estudos

O learning path oficial no MyLearn cobre os sete domínios da prova em cerca de 5 a 6 horas de vídeo. O material está mais atualizado que o da OCI Foundations e reflete bem o portfólio atual da Oracle em IA, inclusive os serviços novos de Generative AI e o Vector Search no 23ai.

Diferente de outras certificações de cloud que viraram decoreba de nome de serviço, essa prova mistura conceito com produto. Você precisa entender ML o bastante para escolher entre as diversas abordagens e não apenas saber o nome de um serviço.

A Oracle diz no material oficial que a certificação não tem pré-requisito técnico. Isso é tecnicamente verdade, mas com uma ressalva: quem tem alguma base de desenvolvimento ou já trabalha com dados absorve o conteúdo muito mais rápido. Quem está totalmente fora dessa área pode passar, mas vai precisar de mais tempo para sedimentar o vocabulário.

Ritmo sugerido:

Para quem trabalha com desenvolvimento ou dados mas nunca pegou IA a sério: três semanas dão conta. Primeira semana nos conceitos de ML e deep learning. Segunda nos serviços Oracle. Terceira em revisão e simulado.

Para quem está chegando do zero: quatro semanas, uma hora por dia. O material conceitual precisa de tempo para se solidificar.

Prazo importante: a versão 2025 se aposenta em 29 de maio de 2026, antes da OCI Foundations. Quem está mirando pegar as duas versões 2025, comece pela AI Foundations.

Parte 4 - Plano de estudos

Semana 1 - Fundamentos de IA e ML

Dias 1 e 2: Módulos de AI Foundations e ML Foundations no MyLearn. Entenda a diferença entre supervisionado (rótulos, tipo spam/não-spam), não supervisionado (sem rótulos, o modelo encontra cluster sozinho) e reinforcement learning (aprende por recompensa e punição). Para cada tipo, tente pensar num exemplo de situação real. Isso ajuda a fixar.

Dias 3 e 4: Deep Learning. Rede neural, como os pesos ajustam via backpropagation, CNN para imagem, RNN para sequência. Faça flashcards para as métricas (accuracy, precision, recall, F1), com exemplos onde cada uma é mais importante.

Dia 5: Generative AI e LLMs. Transformer, atenção, embedding, tokenização. E principalmente: RAG vs fine-tuning. Vai cair com certeza. Estude a diferença, os casos de uso de cada um, e onde cada um falha.

Semana 2 - Portfólio Oracle

Dias 1 e 2: OCI Generative AI Service (modelos disponíveis, chat, embedding, fine-tuning com T-Few). Depois, Oracle Database 23ai e AI Vector Search: o tipo VECTOR, função de similaridade no SQL, índice vetorial.

Dias 3 e 4: OCI AI Services. Para cada um, memorize a tríade entrada-saída-caso de uso:

- Vision: imagem → objeto/texto/face

- Language: texto → sentimento/entidade/idioma

- Speech: áudio → transcrição com timestamp

- Document Understanding: documento → campo extraído e estrutura

- Anomaly Detection: série temporal → anomalia com score

Dia 5: OCI Data Science e Data Labeling. O fluxo completo: rotular dados, treinar modelo, registrar no Model Catalog, deployar como endpoint.

Semana 3 - Revisão e simulados

Dias 1 e 2: Volte nos pontos de maior dificuldade. RAG vs fine-tuning, métricas de avaliação, mapa dos serviços pré-treinados.

Dias 3 e 4: Dois simulados completos, cronometrados. O MyLearn tem practice exam. Anote em quais domínios você errou mais.

Dia 5: Revisão final, focada nos erros dos simulados. OCI AI Portfolio e OCI Generative AI/23ai somam 40% da prova. Eles têm prioridade.

Parte 5 - Por que essa certificação é importante

O mercado de IA mudou muito nos últimos dois anos. Em 2023, construir aplicação com IA queria dizer treinar modelo próprio ou consumir API de terceiros e amarrar tudo no código. Hoje, as nuvens entregam uma camada inteira de serviços gerenciados. Você faz análise de sentimento, transcrição, OCR estruturado, busca semântica e geração de texto chamando API, sem escrever uma linha de código de ML.

O problema agora não é o "como", é o "o quê". São opções demais e a curva de aprendizado para entender qual resolve seu problema é lenta. Você pesquisa uma solução, implementa, e meses depois descobre que tinha um serviço gerenciado fazendo aquilo na metade do esforço. Já passei por isso várias vezes e você vai passar também.

A OCI AI Foundations resolve esse problema para o portfólio Oracle. Você vai ficar sabendo que o Anomaly Detection existe para série temporal, que o Document Understanding vai além de OCR, que o Vector Search no Database 23ai permite RAG sem stack paralelo. E é esse tipo de conhecimento que afeta decisões de arquitetura de um projeto.

Para quem está construindo solução com IA neste momento, essa é a certificação com retorno mais imediato. O conteúdo é aplicável amanhã, não daqui a um ano.

O prazo da versão atual é 29 de maio de 2026. Menos tempo do que a OCI Foundations. Se você está pensando em pegar mais de uma versão 2025, faz sentido começar por aqui.