Olá! É um prazer enorme estar aqui com Tiago. Vamos iniciar nosso curso de Docker e Machine Learning (aprendizado de máquina) para Produção. Trata-se de um curso centrado no uso do Docker para o processo de implantação de modelos de Machine Learning (aprendizado de máquina). O que veremos é aplicável à implantação de qualquer tipo de solução.
Meu nome é Julio Espitora.
Audiodescrição: Julio é um homem branco, veste uma camisa azul e está sentado em frente ao computador. Ao fundo, há uma parede em tons de azul e lilás.
Como início da nossa trajetória, vamos fazer o setup (configuração) do nosso projeto de Machine Learning (aprendizado de máquina), entender as tecnologias envolvidas e quais são os pré-requisitos para continuar com este treinamento. Neste primeiro momento, o objetivo será desenvolver o projeto de Machine Learning (aprendizado de máquina) que utilizaremos nos módulos seguintes. Ao final de cada módulo, sempre nos perguntaremos qual seria o próximo passo; esse questionamento orientará o que iniciaremos no módulo seguinte.
A estrutura do curso será organizada da seguinte forma:
Sobre requisitos obrigatórios: para o desenvolvimento deste curso, é aconselhável utilizar o Docker Desktop. Disponibilizamos os links para download no Windows, macOS e Linux.
GitHub: se você utiliza Windows, será necessário realizar a instalação. Também instalaremos o Visual Studio Code, que é o editor que nós vamos utilizar. Você pode usar o Cursor, o Antigraft ou qualquer outro com o qual tenha mais familiaridade.
Sobre a metodologia que vamos empregar, você terá acesso a um repositório completo com todos os módulos desenvolvidos. Contudo, no início do nosso treinamento, construiremos um repositório do zero. Qual é o objetivo? Construiremos um repositório do zero e criaremos um ramo inicial, no qual desenvolveremos o Módulo 1. O resultado desse ramo, isto é, do primeiro módulo, será o modelo de Machine Learning (Aprendizado de Máquina). Esse modelo será utilizado no Módulo 2. Criaremos um ramo separado para o Módulo 2 e avançaremos assim até concluirmos todos os módulos. Cada módulo estará isolado em um ramo separado. Esse será o percurso do nosso curso.
Em um primeiro momento, construiremos um repositório. Em seguida, cada módulo será um projeto isolado. No primeiro módulo, desenvolveremos o modelo. No módulo seguinte, vamos colocá-lo em contêiner. À medida que avançarmos, sempre herdaremos o que foi desenvolvido nos módulos anteriores; cada projeto herda o que foi desenvolvido no módulo anterior. Ao final de cada módulo, faremos uma avaliação do que foi desenvolvido e proporemos os próximos passos. Isso guiará os módulos seguintes.
Ao concluir o primeiro módulo, verificaremos quais serão os primeiros passos com o objetivo de realizar o deploy (implantação) do nosso modelo, para que outras pessoas possam consumi-lo. Ao final do Módulo 2, buscaremos boas práticas, avaliando se convém adicionar contêineres para treinamento e inferência. Assim, desenvolveremos nosso treinamento.
Obrigado pela atenção. Estou muito entusiasmado. Este é um curso que eu acredito que vai contribuir muito para sua carreira como pessoa desenvolvedora e pessoa engenheira de Machine Learning (Aprendizado de Máquina). Nos vemos na nossa próxima aula.
Olá a todas as pessoas. Vamos iniciar o nosso módulo 1, mas, antes de tratar de Docker, Deploy (implantação) e outros assuntos específicos, vamos desenvolver e apresentar qual será o projeto que utilizaremos ao longo do nosso treinamento na Alura.
O projeto que vamos desenvolver refere-se a um modelo de regressão para prever uma variável específica. Neste caso, vamos analisar um processo industrial real: um trocador de calor e resfriamento.
É possível que esse tema pareça distante da nossa área de conhecimento. No entanto, vamos entendê-lo de forma direta. Neste momento, estamos simulando um processo de análise de negócios. Quando estivermos trabalhando em um ambiente industrial, não necessariamente conheceremos todos os projetos e processos. Durante uma reunião, alguém com domínio do assunto nos transmitirá o necessário para que possamos desenvolver nossos modelos de machine learning (aprendizado de máquina). É isso que vamos fazer neste primeiro momento.
Trata-se, portanto, de um trocador de calor e resfriamento. Basicamente, temos um fluido quente que desejamos resfriar. Como isso acontece? Imaginemos um tubo pelo qual circula água fria por dentro e, por fora desse tubo, circula um fluido quente. Consideremos que o tubo seja de alumínio ou cobre: sua superfície se resfria devido ao fluido frio interno, e ocorre um intercâmbio de calor. Assim, o fluido quente que circula por fora é resfriado em função da troca de calor entre o tubo frio e o fluido quente externo. Esse é o objetivo do processo que vamos revisar.
Dentro deste dataset (conjunto de dados), teremos acesso a uma única variável de interesse: eficiência térmica. O que é eficiência térmica? Imaginemos que, ao iniciar o processo, o equipamento apresenta eficiência máxima. À medida que o tempo passa e utilizamos esse equipamento, sua eficiência tende a diminuir. É semelhante ao que ocorre com um celular: ao comprá-lo, a eficiência da bateria é máxima (100%). Com o uso, essa eficiência diminui, reduzindo a capacidade de carga que a bateria consegue armazenar. Aqui, observamos um comportamento análogo: no início do processo, o trocador de calor possui eficiência máxima, que se reduz com o tempo e com o uso do equipamento.
Concordamos que a variável eficiência térmica tende a apresentar um comportamento próximo de uma reta ao longo do tempo. Isso nos oferece um primeiro insight (percepção): podemos utilizar uma regressão linear para ajustar este dataset (conjunto de dados) real. A regressão linear é um modelo simples, no qual a eficiência térmica é expressa como um parâmetro somado a outro parâmetro que multiplica o tempo. Para formalizar essa ideia de forma simples, podemos expressar o modelo assim:
y = β₀ + β₁ . t
β₁: coeficiente angular.
β₀: intercepto
Esse é um forte indício de que a regressão linear poderá ser o modelo que vamos utilizar. Ou seja, prevemos a eficiência térmica y em função do tempo t por meio de uma relação linear, onde β₀ representa o valor inicial (intercepto) e β₁ a taxa de variação ao longo do tempo (inclinação).
Imaginem o seguinte cenário: temos o comportamento da eficiência térmica variando de 96 até aproximadamente 93, 92. Se o limite de eficiência permitido é 90%, em que momento o processo atingirá essa eficiência? Não temos esse valor diretamente disponível.
É exatamente isso que vamos fazer: desenvolver um modelo para realizar previsões sobre o comportamento dessa variável, permitindo antecipar comportamentos futuros da variável de interesse. Este é o nosso projeto. Agora, vamos colocar em prática, entender como vamos começar e como conduziremos o curso.
No GitHub, teremos acesso a links que apresentam os repositórios. Neste caso, utilizaremos o nosso repositório pessoal, incluindo um repositório chamado Docker Deploy Machine Learning — Docker Deploy Machine Learning (implantação de aprendizado de máquina com Docker). Lá estão todos os módulos desenvolvidos, os pipelines (fluxos de processamento) e os materiais. Ao acessar o módulo 1, teremos acesso a todo o código, aos dados e às imagens.
Neste primeiro momento, vamos fazer algo diferente: criar um repositório do zero, cloná-lo na máquina local e iniciar o desenvolvimento do projeto.
Temos nossa lista de repositórios. O que vamos fazer agora? Vamos criar um repositório do zero com o nome docker-ml-projeto. Esse será o nome do repositório, mas é possível escolher outro nome e adicionar uma descrição, caso faça sentido. Não vamos adicionar o arquivo README neste momento, pois iremos criá-lo manualmente. O repositório será público. Com isso, podemos criar o repositório.
Com o repositório vazio criado, a plataforma exibe um guia de quick start (início rápido) explicando como cloná-lo. É exatamente isso que vamos fazer agora. Estamos utilizando macOS, mas em Windows o processo é similar; entretanto, no Windows é necessário instalar o Git previamente.
Com o Git instalado, abrimos o terminal e navegamos até a pasta "Documents". Primeiro, acessamos a pasta e listamos o conteúdo para confirmar onde estamos:
cd Documents
ls
Esse ls nos mostra as pastas disponíveis; a seguir, encontramos a pasta "Docker" e acessamos "Docker". Também vamos limpar a tela e listar novamente o conteúdo para facilitar a visualização:
cd Docker
clear
ls
Dentro de "Docker", identificamos a pasta "Materiais" e acessamos "Materiais":
cd Materiais
A partir daí, clonamos o repositório recém-criado, copiando o endereço indicado na interface do GitHub e executando o comando de clonagem apropriado:
git clone https://github.com/JullesMitoura/docker-ml-projeto.git
O repositório vazio foi clonado com sucesso.
Em seguida, abrimos o VS Code em uma nova janela, ajustamos o tamanho para melhor visualização e localizamos a pasta "Documents" > "Docker" > "Materiais" > "docker-ml-projeto". Confirmamos que estamos conectados à pasta onde o repositório foi clonado e, a partir desse ponto, podemos iniciar o desenvolvimento do projeto.
Na próxima aula, partiremos exatamente deste ponto para iniciar efetivamente o desenvolvimento do projeto.
Esperamos que tenham conseguido acompanhar. Em caso de dúvidas, registrem no nosso portal; nós vamos buscar solucioná-las para que possam seguir o curso com boa eficiência e aproveitamento. Muito obrigado. Nos vemos na próxima aula.
Olá, pessoal. Entendemos que podem estar ansiosos para começarmos o desenvolvimento de código, e é exatamente isso que vamos fazer neste primeiro momento.
Antes de tudo, vamos mostrar o material ao qual teremos acesso. É o conteúdo do módulo 1, com acesso ao código completo. Porém, o interessante é construirmos tudo do zero. Temos a base de dados e a imagem do trocador de calor. Esse é o ponto de partida para este momento inicial. Vamos estruturar nosso código.
Primeiro, vamos abrir o terminal integrado e criar uma nova branch com git checkout -b modulo-01. Assim, criamos a branch do módulo 01.
Agora, quanto à estrutura do projeto, vamos criar as pastas "data" e "imagem". Basicamente, os arquivos fornecidos serão copiados para dentro dessas pastas. Na pasta "data", colocamos os dados do trocador de calor (o banco SQLite). Na pasta "imagem", colocamos a imagem do equipamento. Tudo pronto.
Ao carregar a base de dados, que é um SQLite, conseguimos visualizar os dados porque instalamos uma dependência local chamada SQLite Viewer. É necessário instalar essa extensão para visualizar a base de dados da mesma forma demonstrada. Perfeito.
Vamos criar o arquivo .gitignore e o requirements.txt, onde apresentamos as bibliotecas e versões que vamos utilizar.
Em seguida, entraremos na etapa de criação do ambiente virtual no qual vamos desenvolver o projeto. Antes disso, vamos criar o README.md, onde colocaremos as instruções a serem seguidas para desenvolver este projeto. No primeiro módulo, vamos desenvolver um projeto de machine learning (aprendizado de máquina) para a predição da eficiência de troca térmica. Esse é o objetivo do projeto.
Passo 01: criar o ambiente virtual, que chamaremos de .venv. Para criá-lo, utilizamos o comando python -m venv .venv. Em macOS, quando há várias versões instaladas, podemos indicar explicitamente a versão: python3.11 -m venv .venv. O trecho entre crases será exibido como bloco de código no README.md por ser uma marcação de Markdown. Nesse comando, criamos um ambiente virtual (venv) e atribuímos a ele o nome .venv. Perfeito.
Para registrar o comando no material do projeto (ex.: README), podemos usar:
python -m venv .venv
Em macOS, quando houver várias versões instaladas:
python3.11 -m venv .venv
Agora precisamos ativar o ambiente virtual. Em macOS e Linux, usamos source .venv/bin/activate. Em Windows, usamos .venv\Scripts\activate.bat. Assim, ativamos o ambiente adequadamente conforme o sistema operacional. Observamos no terminal a indicação de que o ambiente foi ativado.
macOS/Linux:
source .venv/bin/activate
Windows:
.venv\Scripts\activate.bat
Se visualizarmos o controle de versão, veremos muitos arquivos modificados (podem ser mais de mil) porque tudo dentro de .venv será versionado se não ignorarmos. Portanto, no .gitignore, vamos adicionar a linha .venv para não considerar as alterações e os arquivos dessa pasta. Ao mapear as mudanças novamente, aqueles arquivos deixam de ser listados, pois pertenciam ao .venv. Perfeito.
Adicione ao .gitignore:
.venv
Como iniciamos um projeto? Primeiro, fazemos o preparo do ambiente, que acabamos de concluir. Agora, podemos tentar visualizar os dados. Há uma coluna de timestamp (carimbo de data e hora), uma série de temperaturas, e a variável de interesse no momento é heat efficiency (eficiência de troca térmica).
Vamos criar a primeira etapa, chamada análise exploratória de dados. Essa etapa é importante para visualizarmos os dados e extrairmos percepções com base em métricas estatísticas: verificar dados faltantes, identificar valores atípicos, e decidir se é necessário algum pré-processamento no conjunto de dados antes de treinar o modelo. É isso que faremos neste primeiro momento. Este notebook será o de análise exploratória de dados.
Precisamos importar esse conjunto de dados. Poderíamos usar a biblioteca nativa de SQLite, mas, como em outras disciplinas já utilizamos SQLAlchemy, vamos utilizar SQLAlchemy aqui também.
Antes, precisamos garantir que o ambiente do notebook esteja configurado. Se tentarmos, por exemplo, import pandas as pd, como ainda não instalamos, ao executar uma célula o Jupyter pedirá para instalarmos o ipykernel dentro deste ambiente. Após a instalação do ipykernel, a execução indicará que não há pandas. Então, no requirements.txt, adicionamos pandas e instalamos com pip install -r requirements.txt. Em seguida, ao reiniciar e executar, a importação funcionará corretamente.
Para a importação com Pandas, começamos com:
import pandas as pd
Como ainda não adicionamos o pacote, vamos incluir no arquivo de dependências e instalar:
pandas
Agora instalamos:
pip install -r requirements.txt
Como precisamos carregar a base de dados e vamos usar SQLAlchemy, faremos from sqlalchemy import create_engine. Se a importação falhar, adicionamos SQLAlchemy ao requirements.txt e executamos novamente pip install -r requirements.txt. Assim, conseguiremos importar create_engine sem problemas.
Importe o create_engine:
from sqlalchemy import create_engine
Se necessário, adicione ao requirements:
sqlalchemy
E instale:
pip install -r requirements.txt
É importante documentarmos esses processos no README.md do projeto. O terceiro passo, portanto, é instalar as dependências com pip install -r requirements.txt, que lerá todas as bibliotecas listadas e as instalará.
O próximo passo é a leitura do conjunto de dados. Para isso, vamos usar create_engine para criar uma engine de conexão. Precisamos passar a URL do SQLite com o caminho do arquivo. Adotaremos o padrão sqlite:///CAMINHO/DO/ARQUIVO.sqlite, que podemos montar com uma f-string (string formatada). A engine apenas aponta para a base de dados; para ler os dados, vamos criar um DataFrame com pandas.read_sql, passando a consulta (query) e a engine. Em seguida, exibimos df.head() para ver as primeiras linhas.
Vamos construir isso progressivamente, como mostrado em aula:
Primeiro, declaramos a intenção de criar a engine (ainda sem parâmetros, apenas para mostrar a necessidade):
# passo 1: leitura do dataset
engine = create_engine()
Percebemos que precisamos indicar o caminho para o arquivo do banco:
path = "data/heat_exchanger.db"
engine = create_engine(path)
Corremos, então, para o formato correto da URL do SQLite (com f-string):
engine = create_engine(f"sqlite:///{path}")
Agora, lemos a tabela e inspecionamos as primeiras linhas:
df = pd.read_sql("SELECT * FROM heat_exchanger", engine)
df.head()
Observamos que funciona. Temos timestamp, as variáveis de temperatura e a heat efficiency. Podemos inspecionar os nomes das colunas com df.columns e veremos algo como timestamp, water inlet temperature, além das temperaturas de entrada e saída. Relembrando a explicação simplificada do processo: temos um fluxo de água que entra e um fluxo de fluido quente que entra e sai. A partir daqui, podemos seguir com a análise exploratória e, posteriormente, o pré-processamento e o treinamento do modelo.
Essas temperaturas, water inlet temperature (temperatura de entrada da água) e liquid inlet temperature (temperatura de entrada do fluido), correspondem aos fluxos que estão entrando e saindo do nosso equipamento. Por ora, isso não é obrigatório.
Vamos verificar as informações sobre nossos dados. Todos os dados numéricos estão como float. Entretanto, timestamp está como string, o que não é adequado. Precisamos converter essa variável para o tipo data (datetime). Portanto, ao fazermos a leitura, vamos tomar o dataframe, selecionar a coluna timestamp e convertê-la para datetime. Além disso, vamos criar uma nova coluna chamada day_index, que é basicamente um contador de dias.
Para isso, executamos:
df.info()
Em seguida, fazemos as transformações necessárias:
df['timestamp'] = pd.to_datetime(df['timestamp'])
df['day_index'] = (df['timestamp'] - df['timestamp'].min()).dt.days
df.info()
É interessante verificar se existem dados faltantes (nulos), pois isso pode ser um problema. Para isso, usamos df.isnull().sum(), que mostra a soma por coluna. Não há dados faltantes, o que é um problema a menos a resolver.
# verificar se existem dados faltantes
df.isnull().sum()
Também podemos verificar algumas estatísticas com df.describe(). timestamp não faz sentido analisar nesse contexto; faz sentido observar a eficiência de troca térmica, por exemplo. O valor mínimo é 93 e o valor máximo é 96. Isso já remete ao que discutimos: se quisermos responder à pergunta “Quando a eficiência vai atingir 90%?”, esses dados indicam que não temos essa resposta, porque o valor mínimo observado é 93.
# verificar estatisticas
df.describe()
Passo 2: Visualização de dados. Vamos importar o Matplotlib. Ao tentar executar a importação, não funciona. Voltamos ao arquivo requirements.txt e adicionamos matplotlib. Também poderíamos instalar via linha de comando com pip install -r requirements.txt. Executamos e as dependências são instaladas. Removemos a célula utilizada para instalação. Tentando importar novamente, funciona.
Adicionando a dependência:
matplotlib
E instalando:
pip install -r requirements.txt
O que vamos plotar neste momento? Criamos plt.figure para definir as dimensões e usamos plt.plot. Vamos plotar df.day_index no eixo x e a eficiência de troca térmica no eixo y. Em seguida, definimos os rótulos com plt.xlabel e plt.ylabel, ativamos plt.grid() e chamamos plt.show(). Observamos que a eficiência térmica aumenta, atinge um valor máximo e diminui à medida que avançamos no tempo e no uso do equipamento. Por ora, isso está funcionando e conseguimos visualizar e entender o processo que estamos observando.
import matplotlib.pyplot as plt
# passo 2: visualização dos dados
plt.figure(figsize=(12, 6))
plt.plot(df['day_index'], df['heat_efficiency'])
plt.xlabel('Day Index')
plt.ylabel('Heat Efficiency')
plt.grid()
plt.show()
Agora, vamos verificar que tipo de modelo podemos usar para predizer o comportamento dessa variável. Concordamos anteriormente que um modelo de regressão linear funcionaria; vamos executar e criar uma reta que ajuste esses dados.
Parte 03: Predição da eficiência térmica. Como já estamos usando Pandas e ele traz o NumPy, vamos utilizar o NumPy para fazer uma regressão neste primeiro momento.
Qual será nossa variável Y? A eficiência de troca térmica. A variável X será o day_index. De ambas as colunas, vamos utilizar apenas os values. Se imprimirmos os valores de X, teremos basicamente os dias; se imprimirmos Y, teremos um array com todos os valores de eficiência.
import numpy as np
y = df['heat_efficiency'].values
x = df['day_index'].values
Vamos encontrar os coeficientes da reta usando NumPy. Para isso, usamos np.polyfit, passando X e Y, e indicamos que é de grau 1 (reta). Importamos o NumPy como np. Ao imprimir esses coeficientes, obtemos dois parâmetros (inclinação e intercepto), conforme verificamos anteriormente.
# encontrar os coeficientes da reta utilizando numpy
coef = np.polyfit(x, y, 1)
print(coef)
Como usamos esses coeficientes para calcular a reta? Poderíamos criar uma função manual, mas o NumPy já fornece np.polyval. Passamos os coeficientes e os valores de X, e obtemos as predições. Assim, recalculamos os valores de Y com base no modelo obtido e já conseguimos calcular a eficiência de troca térmica usando regressão linear.
pred = np.polyval(coef, x)
Para visualizar isso manualmente, retomamos aquele gráfico: adicionamos uma curva com os dados reais (exibidos como pontos) e fazemos outro plot com os dados calculados, passando X e os valores previstos. Definimos as devidas labels e chamamos plt.legend() para exibir “dados reais” e “dados calculados”. Visualmente, parece funcionar muito bem: a reta ajusta bem o processo observado, com algum desvio no início e no fim, mas ainda é um modelo simples que produz um resultado valioso.
plt.plot(df['day_index'], df['heat_efficiency'], 'o', label = "Dados Reais")
plt.plot(x, pred, label = "Dados Calculados")
plt.legend()
Também podemos verificar o efeito de aumentar o grau do polinômio. Se utilizarmos um polinômio de grau 2, visualmente parece melhorar a predição. Contudo, vamos nos limitar a utilizar apenas uma reta (grau 1), por ser um modelo mais simples e interpretável. Fica o desafio de experimentar outros modelos.
Como obter uma métrica para avaliar se nosso ajuste é realmente bom, isto é, se os dados calculados se aproximam dos dados reais? Vamos calcular o R². Podemos importar do scikit-learn, mas também podemos fazê-lo manualmente:
Ao imprimir o R², obtemos aproximadamente 0,99, o que indica um bom ajuste: nossa reta ajustou muito bem o conjunto de dados. Testando um polinômio de grau 2, a métrica permanece muito próxima, algo em torno de 0,99. Voltamos, então, ao modelo linear, que será o utilizado neste projeto.
Aqui está o cálculo manual do R²:
# calculo do r2
residuos = y - pred
ss_res = np.sum(residuos**2)
ss_tot = np.sum((y - np.mean(y))**2)
r2 = 1 - (ss_res / ss_tot)
print(r2)
Por que usamos o modelo linear? Porque, ao desenvolvermos este projeto em um cenário real, foi o modelo que teve menor impacto de possíveis anomalias no comportamento dessa variável. Naquele momento, usamos o modelo linear por ser o que mais se aplicava a distintos conjuntos de dados. Para este conjunto, o polinômio de grau 2 funciona bem, mas, de modo geral, observamos que o polinômio de grau 1 tinha maior capacidade de adaptação a diversos cenários.
Com isso, concluímos nossa primeira etapa, na qual fizemos a análise exploratória. Conseguimos verificar qual modelo ajusta melhor este conjunto de dados e obtivemos a métrica R². Primeiro calculamos os resíduos, depois a soma dos erros ao quadrado e, em seguida, a soma da variação total em relação à média; com isso, obtivemos o R². No treinamento e desenvolvimento do modelo, utilizaremos scikit-learn e consumiremos as funções já prontas.
Encerramos nossa primeira etapa. Na próxima aula, traremos o processo de treinamento do modelo e, depois, escreveremos o processo de inferência. Por ora, temos um bom resultado e demos um primeiro passo consistente. Nos vemos na próxima aula.
O curso Docker: machine learning para produção possui 567 minutos de vídeos, em um total de 106 atividades. Gostou? Conheça nossos outros cursos de Engenharia de Dados em Data Science, ou leia nossos artigos de Data Science.
Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:
O Plano Plus evoluiu: agora com Luri para impulsionar sua carreira com os melhores cursos e acesso à maior comunidade tech.
2 anos de Alura
Matricule-se no plano PLUS 24 e garanta:
Jornada de estudos progressiva que te guia desde os fundamentos até a atuação prática. Você acompanha sua evolução, entende os próximos passos e se aprofunda nos conteúdos com quem é referência no mercado.
Programação, Data Science, Front-end, DevOps, Mobile, Inovação & Gestão, UX & Design, Inteligência Artificial
Formações com mais de 1500 cursos atualizados e novos lançamentos semanais, em Programação, Inteligência Artificial, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.
A cada curso ou formação concluído, um novo certificado para turbinar seu currículo e LinkedIn.
Acesso à inteligência artificial da Alura.
No Discord, você participa de eventos exclusivos, pode tirar dúvidas em estudos colaborativos e ainda conta com mentorias em grupo com especialistas de diversas áreas.
Faça parte da maior comunidade Dev do país e crie conexões com mais de 120 mil pessoas no Discord.
Acesso ilimitado ao catálogo de Imersões da Alura para praticar conhecimentos em diferentes áreas.
Explore um universo de possibilidades na palma da sua mão. Baixe as aulas para assistir offline, onde e quando quiser.
Luri Vision chegou no Plano Pro: a IA da Alura que enxerga suas dúvidas, acelera seu aprendizado e conta também com o Alura Língua que prepara você para competir no mercado internacional.
2 anos de Alura
Todos os benefícios do PLUS 24 e mais vantagens exclusivas:
Chat, busca, exercícios abertos, revisão de aula, geração de legenda para certificado.
Envie imagens para a Luri e ela te ajuda a solucionar problemas, identificar erros, esclarecer gráficos, analisar design e muito mais.
Aprenda um novo idioma e expanda seus horizontes profissionais. Cursos de Inglês, Espanhol e Inglês para Devs, 100% focado em tecnologia.
Escolha os ebooks da Casa do Código, a editora da Alura, que apoiarão a sua jornada de aprendizado para sempre.
Para quem quer atingir seus objetivos mais rápido: Luri Vision ilimitado, vagas de emprego exclusivas e mentorias para acelerar cada etapa da jornada.
2 anos de Alura
Todos os benefícios do PRO 24 e mais vantagens exclusivas:
Catálogo de tecnologia para quem é da área de Marketing
Envie imagens para a Luri e ela te ajuda a solucionar problemas, identificar erros, esclarecer gráficos, analisar design e muito mais de forma ilimitada.
Escolha os ebooks da Casa do Código, a editora da Alura, que apoiarão a sua jornada de aprendizado para sempre.
Conecte-se ao mercado com mentoria individual personalizada, vagas exclusivas e networking estratégico que impulsionam sua carreira tech para o próximo nível.
