Keras: o que é, como funciona e como usar na prática com Python

Keras é uma biblioteca de código aberto para construir redes neurais e modelos de deep learning com Python. Ela foi criada com um propósito bem definido: tornar o desenvolvimento com inteligência artificial (IA) mais simples e acessível.

Como destaca a própria documentação oficial, o Keras foi feito “para seres humanos, não para máquinas”. 

Por que usar o Keras?

• API simples e intuitiva, ideal para iniciantes e profissionais;
• Permite criar modelos avançados com poucas linhas de código;
• A partir da versão Keras 3.0 (lançada em 2023), passou a suportar vários backends: TensorFlow, PyTorch, JAX e OpenVINO;
• Flexibilidade total: você pode trocar o backend do projeto sem precisar reescrever o código;
• Multiplataforma: roda em CPU, GPU, TPU, no computador local, na nuvem e até em dispositivos móveis.

Para que serve o Keras?

Com o Keras, você pode criar, treinar e testar redes neurais de forma rápida. Ele é útil em várias aplicações práticas, como:

• Classificação de imagens, como identificar se uma foto é de um gato ou cachorro;
• Reconhecimento de voz e detecção de rostos;
• Análise de sentimentos em textos;
• Previsão de séries temporais (como vendas ou faturamento);
• Chatbots e geração de texto;
• Análises financeiras, como previsão de preços de ações;
• Monitoramento de sensores em aplicações de IoT.

Keras vs TensorFlow vs PyTorch: qual a diferença?

Keras, TensorFlow e PyTorch são algumas das ferramentas mais usadas no desenvolvimento de modelos de IA.

Entenda as principais diferenças entre elas a seguir:

• Keras é a mais simples de todas. Possui uma API intuitiva, código limpo e é ótima para prototipagem rápida. Por isso, é indicada para quem está começando;
• TensorFlow, desenvolvido pelo Google, é robusto e escalável. Ideal para aplicações em produção e grandes volumes de dados. É uma das bibliotecas mais usadas por empresas e, inclusive, é o backend original do Keras;
• PyTorch, criado pela Meta (Facebook), é o queridinho de quem trabalha com pesquisa em IA. É flexível, fácil de depurar e excelente para testes rápidos e experimentação.

Comparativo rápido

Como funciona o Keras? 

Pense no Keras como uma fábrica de redes neurais. Você escolhe as peças (camadas, ativações, otimizadores), monta o modelo e coloca para rodar.

Na prática, um modelo Keras funciona como uma receita de bolo: precisa dos ingredientes certos, na ordem certa, para funcionar bem. Esses “ingredientes” são os componentes básicos que você combina para montar e treinar uma rede neural.

Veja os principais:

Camadas (layers)

São o coração da rede neural. A mais comum é a Dense, que representa uma camada totalmente conectada. Cada camada recebe dados, aplica cálculos e envia os resultados para a próxima camada.

Funções de ativação

São funções matemáticas que dizem como os neurônios reagem aos dados. Elas ajudam o modelo a entender padrões mais complexos.

As mais usadas são:

• ReLU: usada nas camadas ocultas, permite aprender relações não lineares;
• Softmax: transforma os resultados da saída em probabilidades (ótima para classificação multiclasse).

Função de perda (loss function)

Ela mede o erro entre a previsão do modelo e o valor real. Ela é como uma bússola que guia o modelo durante o treino, ajudando-o a aprender com os próprios erros.

Otimizador

Ajusta os pesos da rede durante o treinamento para reduzir o erro. Para isso, usa uma técnica chamada descida do gradiente.

Alguns otimizadores populares incluem:

• SGD (Stochastic Gradient Descent): simples e eficiente;
• Adam: mais avançado, se adapta automaticamente ao problema.

Métricas de avaliação

Servem para avaliar o desempenho do modelo, mas não interferem no aprendizado. A mais comum é a accuracy (acurácia), que mostra quantas previsões o modelo acertou.

API Sequencial vs API Funcional: qual a diferença?

Antes de sair programando, você também precisa entender os dois principais jeitos de construir modelos com essa biblioteca: a API Sequencial e a API Funcional.

API Sequencial

A API Sequencial é ideal para quem está começando. Nela, você empilha as camadas uma a uma, como blocos de LEGO, o que torna o código direto e fácil de entender.

É indicada para tarefas com fluxo linear, como:

• Classificação básica, como imagens ou textos;
• Análise de sentimentos;
• Modelos com uma entrada e uma saída, sem bifurcações.

Exemplo de modelo sequencial:

from keras.models import Sequential
from keras.layers import Dense

model = Sequential([
    Dense(64, activation='relu', input_shape=(100,)),  # Camada oculta
    Dense(10, activation='softmax')                    # Camada de saída
])

from keras.models import Sequential
from keras.layers import Dense

model = Sequential([
    Dense(64, activation='relu', input_shape=(100,)),  # Camada oculta
    Dense(10, activation='softmax')                    # Camada de saída
])

API Funcional

A API Funcional é mais flexível e recomendada quando você precisa criar modelos mais complexos, com múltiplas entradas, saídas ou conexões não lineares.

Ela é indicada para casos como:

• Redes neurais com múltiplas entradas ou saídas;
• Conexões alternativas, como em redes residuais;
• Camadas compartilhadas entre diferentes partes do modelo.

Exemplo de modelo funcional:

from keras.layers import Input, Dense
from keras.models import Model

# Define a entrada
inputs = Input(shape=(100,))

# Camadas intermediárias
x = Dense(64, activation='relu')(inputs)
outputs = Dense(10, activation='softmax')(x)

# Cria o modelo
model = Model(inputs=inputs, outputs=outputs)

from keras.layers import Input, Dense
from keras.models import Model

# Define a entrada
inputs = Input(shape=(100,))

# Camadas intermediárias
x = Dense(64, activation='relu')(inputs)
outputs = Dense(10, activation='softmax')(x)

# Cria o modelo
model = Model(inputs=inputs, outputs=outputs)

Ambas as abordagens funcionam muito bem no Keras. A escolha depende da complexidade do projeto e da flexibilidade que você precisa.

Como instalar e configurar o Keras?

A versão mais recente da biblioteca é o Keras 3, que você pode instalar em poucos minutos via pip ou pelo Anaconda.

Confira abaixo o passo a passo para cada método:

Instalação com pip (forma mais comum)

1. Instale o Keras

Abra o terminal (ou o prompt de comando, se estiver no Windows) e digite:

pip install keras --upgrade

pip install keras --upgrade

Esse comando instala a versão mais recente do Keras diretamente no PyPI, o repositório oficial de pacotes Python.

2. Instale o backend

O Keras 3 é independente do TensorFlow. Isso significa que você precisa instalar manualmente o backend que vai executar os cálculos do modelo. 

Você pode escolher entre:

Se quiser instalar o Keras com TensorFlow de uma vez, use:

pip install keras tensorflow

pip install keras tensorflow

Instalação com Anaconda (recomendado para quem usa Jupyter)

Se você utiliza o Anaconda para gerenciar ambientes Python (como no Jupyter Notebook), o ideal é criar um ambiente isolado para o Keras. Isso evita conflitos entre pacotes e facilita o controle de dependências.

Para isso, siga o passo a passo abaixo:

1. Crie um novo ambiente com Python 3.10

No terminal (ou Anaconda Prompt), execute:

conda create -n keras-tf python=3.10

conda create -n keras-tf python=3.10

Isso cria um ambiente chamado keras-tf.

2. Ative o ambiente

conda activate keras-tf

conda activate keras-tf

3. Instale o Keras e o TensorFlow

pip install keras tensorflow

pip install keras tensorflow

pip install keras tensorflow

Esse é o combo mais usado e já te permite treinar modelos com o backend TensorFlow.

Dica para usuários Windows:

Se você estiver no Windows e quiser usar recursos avançados (como suporte a GPU ou backends como JAX), o ideal é ativar o WSL2 (Windows Subsystem for Linux). 

Isso garante mais compatibilidade e evita erros comuns com pacotes de IA que rodam melhor em ambiente Linux.

Como configurar o backend (antes de importar o Keras)

A instalação não termina ao rodar pip install. Depois de instalar o Keras, você precisa dizer qual backend ele deve usar antes de importar o pacote no seu script.

Se você importar o keras antes de configurar o backend, ele pode assumir um backend padrão errado ou gerar erro.

Por isso, no início do seu script Python, adicione:

import os
os.environ["KERAS_BACKEND"] = "tensorflow"  # ou "jax", "torch", "openvino"

import keras

import os
os.environ["KERAS_BACKEND"] = "tensorflow"  # ou "jax", "torch", "openvino"

import keras

Se preferir não precisar configurar toda vez, você pode definir o backend de forma permanente criando (ou editando) o arquivo: ~/.keras/keras.json.

E colocando o seguinte conteúdo:

{
  "backend": "tensorflow"
}

{
  "backend": "tensorflow"
}

Quer usar GPU para acelerar o treinamento?

Se você tem uma placa de vídeo da NVIDIA, pode usar o suporte a GPU via CUDA para treinar redes neurais com muito mais velocidade. Essa aceleração faz muita diferença em modelos maiores.

O Keras facilita esse processo oferecendo arquivos de requisitos prontos. Para isso, execute no terminal:

pip install -r requirements-tensorflow-cuda.txt

pip install -r requirements-tensorflow-cuda.txt

Esse comando instala todas as dependências necessárias (como CUDA e cuDNN) para usar GPU com o backend TensorFlow.

Se estiver usando JAX ou PyTorch, troque o nome do arquivo:

pip install -r requirements-jax-cuda.txt
# ou
pip install -r requirements-torch-cuda.txt

pip install -r requirements-jax-cuda.txt
# ou
pip install -r requirements-torch-cuda.txt

Esses arquivos cuidam de tudo o que é necessário para rodar seus modelos na GPU, com os pacotes compatíveis já definidos.

Importante: seu computador precisa ter o driver da NVIDIA instalado corretamente. Para evitar conflitos de versão, o ideal é usar um ambiente Python isolado (como um ambiente criado com conda).

Teste a instalação do Keras com um modelo simples

Agora que o Keras está instalado e o backend configurado, você pode fazer um teste rápido só para garantir que está tudo certo. A ideia aqui é:

• Criar um modelo sequencial simples;
• Treinar com dados aleatórios;
• Verificar se o código roda sem erros.

Para isso, execute o seguinte código de teste:

import os
os.environ["KERAS_BACKEND"] = "tensorflow"  # ou "jax", "torch", "openvino"

import keras
from keras import layers
import numpy as np

# Gerando dados aleatórios para entrada e saída
x = np.random.random((100, 10))
y = keras.ops.convert_to_tensor(np.random.randint(0, 2, size=(100, 1)), dtype="float32")

# Criando um modelo sequencial com duas camadas
model = keras.Sequential([
    layers.Dense(32, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

# Compilando o modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Treinando o modelo
model.fit(x, y, epochs=3, batch_size=8)

# Avaliando o desempenho
loss, acc = model.evaluate(x, y)
print(f"Acurácia: {acc:.2f}")

import os
os.environ["KERAS_BACKEND"] = "tensorflow"  # ou "jax", "torch", "openvino"

import keras
from keras import layers
import numpy as np

# Gerando dados aleatórios para entrada e saída
x = np.random.random((100, 10))
y = keras.ops.convert_to_tensor(np.random.randint(0, 2, size=(100, 1)), dtype="float32")

# Criando um modelo sequencial com duas camadas
model = keras.Sequential([
    layers.Dense(32, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

# Compilando o modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Treinando o modelo
model.fit(x, y, epochs=3, batch_size=8)

# Avaliando o desempenho
loss, acc = model.evaluate(x, y)
print(f"Acurácia: {acc:.2f}")

Se tudo estiver funcionando corretamente, você verá algo como:

Epoch 1/3
...
Acurácia: 0.58

Epoch 1/3
...
Acurácia: 0.58

Isso significa que o modelo foi criado, treinado e avaliado com sucesso, ou seja, a instalação do Keras + backend está funcionando perfeitamente!

Exemplo prático: criando uma rede neural com Keras e Python

Você acabou de instalar o Keras, entendeu os conceitos principais e agora quer ver tudo funcionando na prática? 

Então, vamos montar uma rede neural completa do zero usando o dataset Iris, um dos conjuntos de dados mais clássicos do machine learning.

1. Importe o dataset Iris e prepare os dados

O dataset Iris contém 150 registros de flores, com 4 características numéricas (como tamanho da pétala e da sépala). O objetivo é classificar cada flor em uma das 3 espécies: Setosa, Versicolor ou Virginica.

Para importar o dataset Iris, execute o comando:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from keras.utils import to_categorical
import numpy as np

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from keras.utils import to_categorical
import numpy as np

Em seguida, carregue os dados:

iris = load_iris()
X = iris.data          # Dados de entrada (features)
y = iris.target        # Classes (0, 1 ou 2)

iris = load_iris()
X = iris.data          # Dados de entrada (features)
y = iris.target        # Classes (0, 1 ou 2)

Como temos mais de duas classes, o modelo precisa que os rótulos estejam no formato de vetores binários (ex: [1, 0, 0] para Setosa). 

Por isso, use o seguinte comando:

y_encoded = to_categorical(y)

y_encoded = to_categorical(y)

E, para avaliar o modelo corretamente, separe uma parte dos dados para teste:

X_train, X_test, y_train, y_test = train_test_split(
    X, y_encoded, test_size=0.2, random_state=42
)

X_train, X_test, y_train, y_test = train_test_split(
    X, y_encoded, test_size=0.2, random_state=42
)

Esses parâmetros indicam que:

• test_size=0.2: usa 20% dos dados para teste;
• random_state=42: garante que a separação seja sempre igual (reprodutível).

Com isso, os dados estão prontos para serem usados na construção do modelo.

2. Crie a rede neural com Keras

Vamos usar o modelo Sequential, que é a forma mais simples de montar uma rede neural no Keras.

Pense no Sequential como uma fila de camadas: os dados entram pela primeira camada e vão passando por cada uma, até chegar ao resultado final.

Para isso, vamos construir uma rede com três partes:

• Camada de entrada: não precisa ser criada separadamente. O input_dim=4 já define que a entrada terá 4 neurônios, um para cada característica da flor (comprimento e largura de pétalas e sépalas);
• Camada oculta (intermediária): contém 10 neurônios e usa a função de ativação relu;
• Camada de saída: tem 3 neurônios, representando as 3 espécies de flor e usa a ativação softmax.

Para isso, execute o código:

from keras.models import Sequential
from keras.layers import Dense

modelo = Sequential()
modelo.add(Dense(10, input_dim=4, activation='relu'))  # Camada oculta com 10 neurônios
modelo.add(Dense(3, activation='softmax'))             # Camada de saída com 3 neurônios

from keras.models import Sequential
from keras.layers import Dense

modelo = Sequential()
modelo.add(Dense(10, input_dim=4, activation='relu'))  # Camada oculta com 10 neurônios
modelo.add(Dense(3, activation='softmax'))             # Camada de saída com 3 neurônios

O que esse código faz?

• Cria um modelo sequencial (Sequential);
• Adiciona uma camada densa com 10 neurônios (Dense) e ativações relu;
• Adiciona a camada final com 3 neurônios e ativação softmax para fazer a classificação.

3. Compile e treine o modelo

Com a estrutura da rede pronta, agora você precisa dizer como ela vai aprender. Esse processo se chama compilação.

Ao compilar o modelo, você define três aspectos importantes:

• loss (função de perda): usamos categorical_crossentropy, que é a mais indicada para classificação com mais de duas classes, como é o caso do dataset Iris;
• optimizer (otimizador): usamos o SGD() (Stochastic Gradient Descent), um dos otimizadores mais clássicos e fáceis de entender;
• metrics (métrica de avaliação): a escolhida foi a acurácia (accuracy), que mostra a porcentagem de acertos do modelo.

Para isso, execute o seguinte código:

from keras.optimizers import SGD

modelo.compile(
    loss='categorical_crossentropy',
    optimizer=SGD(),
    metrics=['accuracy']
)

modelo.fit(X_train, y_train, epochs=1000, batch_size=105)

from keras.optimizers import SGD

modelo.compile(
    loss='categorical_crossentropy',
    optimizer=SGD(),
    metrics=['accuracy']
)

modelo.fit(X_train, y_train, epochs=1000, batch_size=105)

O que esse código faz?

• modelo.compile(...): define como o modelo será treinado.
• modelo.fit(...): inicia o processo de treinamento com os dados de entrada (X_train) e saída (y_train).

Sobre os parâmetros do fit():

• epochs=1000: o modelo vai passar pelos dados mil vezes;
• batch_size=105: todos os exemplos de uma vez (já que temos 120 no treino e 105 é maior que isso)

Ou seja, aqui estamos fazendo um treino mais intenso, como se o modelo revisasse o conteúdo repetidamente para memorizar o que precisa aprender.

4. Faça previsões com o modelo

Depois de treinar a rede, é hora de colocar o modelo à prova. Vamos usá-lo para prever a espécie das flores no conjunto de teste (X_test).

Para isso, use o código:

predicoes = modelo.predict(X_test)

predicoes = modelo.predict(X_test)

Esse comando retorna probabilidades para cada classe.

Por exemplo, para uma flor qualquer, o modelo pode retornar:

[0.1, 0.8, 0.1]

[0.1, 0.8, 0.1]

Isso significa que:

• 10% de chance de ser Setosa;
• 80% de chance de ser Versicolor;
• 10% de chance de ser Virginica.

Como saber qual classe o modelo escolheu?

Vamos usar o np.argmax() para pegar o índice da maior probabilidade, que representa a classe prevista:

import numpy as np
classes_previstas = np.argmax(predicoes, axis=1)

import numpy as np
classes_previstas = np.argmax(predicoes, axis=1)

Se quiser comparar com os valores reais, execute:

classes_reais = np.argmax(y_test, axis=1)

classes_reais = np.argmax(y_test, axis=1)

Agora você tem:

• classes_previstas: o que o modelo respondeu;
• classes_reais: as respostas corretas.

Com isso, você consegue avaliar se o modelo está acertando ou não.

Apesar de ser um exemplo simples, essa é a base de qualquer projeto de classificação com IA. 

Então, pode usá-la nos seus projetos!

Quando usar o Keras?

Use o Keras quando você quiser:

• Criar e treinar redes neurais de forma rápida e intuitiva;
• Prototipar ideias com poucas linhas de código;
• Trabalhar com classificação de imagens, processamento de linguagem natural (NPL), séries temporais e outros problemas de IA;
• Utilizar modelos personalizados ou pré-treinados;
• Rodar seus projetos em CPU, GPU, TPU, nuvem, celular ou navegador;
• Compartilhar modelos com quem usa TensorFlow, PyTorch ou JAX.

Quem usa o Keras?

O Keras é uma das bibliotecas de deep learning mais populares do mundo entre iniciantes, empresas e centros de pesquisa de ponta.

Ele está presente em projetos avançados e setores estratégicos como ciência, saúde, transporte, finanças, varejo, educação e entretenimento.

Veja exemplos de instituições e empresas que usam Keras:

• CERN: usa em pesquisas científicas de alto nível, como no Grande Colisor de Hádrons;
• NASA: em projetos de exploração espacial e análise de dados científicos;
• NIH (Institutos Nacionais de Saúde): para estudos médicos e genômicos;
• Waymo (Google/Alphabet): para veículos autônomos e detecção de objetos;
• Google: em sistemas como YouTube e Google Search (recomendações e NLP);
• NVIDIA: para otimização de modelos acelerados por GPU;
• S&P Global: para análise de mercado e previsões econômicas;
• eBay: em sistemas de recomendação e detecção de fraudes;
• Netflix: para personalizar recomendações de filmes e séries.

Além disso, o Keras é parceiro de plataformas como Kaggle e Hugging Face, o que facilita o uso em competições e projetos com modelos prontos.

Quem deve aprender Keras?

Aprender Keras é um diferencial competitivo para quem quer trabalhar com IA ou machine learning. A biblioteca é importante para várias carreiras, como:

• Cientista de dados: na criação de modelos preditivos e classificadores;
• Engenheiro de deep learning: no desenvolvimento de redes neurais para visão computacional e linguagem natural;
• Pesquisador em IA: na prototipagem e teste de novos algoritmos;
• Desenvolvedor de aplicações com IA: integrando modelos em apps, APIs ou sistemas na nuvem.

Veja também:

IA no mercado de trabalho: ameaça ou aliada para sua carreira?

Limitações do Keras

Apesar de ser um dos frameworks mais populares para trabalhar com deep learning, o Keras também apresenta algumas limitações que vale a pena considerar.

Veja suas principais desvantagens abaixo:

• Desempenho inferior em modelos muito grandes, comparado ao TensorFlow puro ou ao JAX;
• Sem suporte nativo a treinamento distribuído, o que dificulta o uso com múltiplas GPUs ou clusters;
• Não trabalha com gráficos computacionais dinâmicos, o que limita a criação de arquiteturas flexíveis (como as feitas no PyTorch);
• É mais indicado para prototipagem do que para uso em produção em larga escala;
• A depuração pode ser difícil, com mensagens de erro pouco claras ou ligadas a bibliotecas internas;
• Oferece menos controle em cenários avançados, como customizações de baixo nível;
• Possui uma comunidade menor e menos exemplos práticos online em comparação com TensorFlow e PyTorch.

Importante: essas limitações não impedem o uso do Keras, mas ajudam a entender quando vale a pena usá-lo e quando pode ser melhor optar por outra ferramenta.

Quer aprender a criar redes neurais com Python do zero?

A Trilha de Data Science e Machine Learning, da Asimov Academy, é o melhor caminho para isso.

Nela, você vai:

• Aprender a criar redes neurais com Python do zero;
• Entender como cada parte funciona na prática;
• Desenvolver as habilidades que o mercado de tecnologia mais procura hoje.

Monte seus próprios modelos, ganhe confiança com projetos reais e domine as ferramentas que estão por trás da inteligência artificial no mundo todo.

Comece agora a mudar seu futuro!

Trilha Data Science e Machine Learning

Explore dados, desenvolva modelos preditivos e extraia insights valiosos para impulsionar a tomada de decisões.

Comece agora