fbpx
Sigmoidal
  • Home
  • Cursos
  • Pós-Graduação
  • Blog
  • Sobre Mim
  • Contato
Sem Resultado
Ver Todos Resultados
  • English
  • Home
  • Cursos
  • Pós-Graduação
  • Blog
  • Sobre Mim
  • Contato
Sem Resultado
Ver Todos Resultados
Sigmoidal
Sem Resultado
Ver Todos Resultados

Armazenamento de grandes quantidades de dados com HDF5

Carlos Melo por Carlos Melo
julho 4, 2019
em Blog, Machine Learning
1
38
COMPARTILHAMENTOS
1.3k
VIEWS
Publicar no LinkedInCompartilhar no FacebookCompartilhar no Whatsapp

Trabalhar com modelos deep learning ou de redes neurais convolucionais (convolutional neural networks – CNN) significa ter que lidar com grandes massas de dados, que chegam facilmente a ordem de gigabytes (ou até terabytes). Não há como escapar disso.

De fato, treinar um modelo de deep learning (DL) não é uma tarefa trivial. Muitas arquiteturas modernas podem chegar a ter milhões de parâmetros diferentes e receberem imagens de altíssima resolução como input.

Imagine um data dataset composto por imagens hiperespectrais (HSI) coletadas por satélites de sensoriamento remoto. Enquanto câmeras comuns capturam imagens em três canais distintos (RGB), um sistema hiperespectral tem resoluções que variam entre 100-1000 canais de espectro contínuo (ou mais).

Figura 1 – Exemplo de imagem hiperspectral (HSI) coletada por um satélite de sensoriamento remoto. Fonte: Boeing.

Dificilmente datasets desse tamanho conseguirão ser processados eficientemente na memória da nossa máquina. Ou seja, para trabalhar com volumes grandes de dados é preciso encontrar uma maneira eficiente e fácil de fazê-lo.

Bem, vamos falar hoje então sobre o modelo de dados HDF5, que vai possibilitar você manipular gigabytes de dados como se estivesse usando um simples array do NumPy.

Afinal, o que é HDF5?

Resumidamente, HDF5 é um modelo de dados que permite que seu conteúdo possa ser facilmente manipulado – mesmo quando o tamanho do dataset ultrapassa os gigabytes.

Baseado em estruturação hierárquica de dados, é um formato muito usado em machine learning e na comunidade acadêmica. Para você acessar as linha (rows) do conjunto de dados, basta usar uma sintaxe de slices, que já estamos acostumados.

Figura 2 – O HDF5 é baseado em estruturação hierárquica de dados, sendo muito usado para deep learning. Fonte: HDFgroup.org

O pacote  h5py torna muito prática e intuitiva a implementação desse modelo de dados. Por utilizar “metáforas” como NumPy arrays e estrutura de mapeamento baseada nos dicionários, a biblioteca permite ao programador Python começar a utilizar imediatamente o HDF5, sem precisar qualquer tipo de  conhecimento mais aprofundado.

HDF5 é um modelo de dados que permite que seu conteúdo possa ser facilmente manipulado, e com grande eficiência.

HDF5 para deep learning em Python

O código que vou escrever aqui vai permitir você criar uma classe que servirá para dois propósitos:

  1. Gerar um dataset HDF5 para armazenar raw images, o que melhora muito a velocidade que leva para treinar as nossas CNN; e
  2. Gerar um dataset para armazenar as features extraídas de CNN já treinadas, facilitando você na hora de aplicar transfer learning.

Neste artigo, vou usar a classe HDF5Dataset para armazenar o conjunto de imagens da competição Dogs vs. Cats do Kaggle. O dataset completo possui 25.000 imagens de gatos e cachorros, e o objetivo da competição é treinar seu algoritmo para dizer se uma imagem escolhida aleatoriamente é classificada como cachorro (label=1) ou gato (label=0).

Após se registrar no Kaggle você é liberado para fazer o download do dataset, que tem a seguinte estrutura:

carlos$ tree -L 1
.
├── sampleSubmission.csv
├── test
└── train
carlos$ ls -1 train/ | wc -l
   25000
carlos$ ls -U train/ | head -2 && ls -U train/ | tail -2
cat.0.jpg
cat.1.jpg
dog.9998.jpg
dog.9999.jpg

No conjunto de treino, realmente são encontradas 25.000 imagens. O padrão dos nomes dos arquivos pode ser visto após o último comando Shell executado acima. So, hands-on! Hora de colocar a mão na massa e começar a escrever código!

Este código é baseado em um dos melhores materiais de DL que tive contato até hoje ( e que definitivamente inspira meus artigos aqui no site): o livro Deep Learning for Computer Vision, de Adrian Rosebrock. Se você, assim como eu, ainda esta engatinhando nessa área, recomendo a sua leitura 🙂

Escrevendo imagens em um dataset HDF5

Vamos começar a escrever a estrutura da class HDF5Dataset que poderá ser usada em qualquer projeto que necessite de eficiência e facilidade na manipulação dos nossos NumPy arrays contendo as raw images. Após, escreveremos um script que importará o dataset train com 25.000 imagens (e seus respectivos labels).

Vou importar todos os pacotes que serão usados no projeto, criar a classe HDF5Data e escrever o método especial __init__, que será chamado quando um objeto da nossa classe for instanciado:

# importar os pacotes necessários
import os
import argparse
from imutils import paths
import progressbar
from sklearn.preprocessing import LabelEncoder
import h5py
import cv2


class HDF5Dataset(object):
    """Escreve o conjunto de dados fornecidos como input (em formato numpy array)
    para um conjunto de dados HDF5.
    :param dims: dimensões dos dados a serem armazenados no dataset
    :param output_path: arquivo onde o arquivo hd5f será salvo
    :param data_key: nome do dataset que armazenará os dados
    :param buffer_size: buffer de memória
    """
    def __init__(self, dims, output_path, data_key='imagens', buffer_size=500):
        # # verifica se o arquivo já existe, evitando seu overwrite.
        if os.path.isfile(output_path):
            raise ValueError("O arquivo '{}' já existe e não pode "
                             "ser apagado.".format(output_path))
        # abrir um database HDF5 e criar 02 datasets:
        #   1. Para armazenar as imagens; e
        #   2. Para armazenar os labels.
        self.db = h5py.File(output_path, 'w')
        self.data = self.db.create_dataset(data_key, dims, dtype='float')
        self.labels = self.db.create_dataset('labels', (dims[0],), dtype='int')
        # Definir o buffer e índice da próxima linha disponível
        self.buffer_size = buffer_size
        self.buffer = {"data": [], "labels": []}
        self.idx = 0

O construtor acima aceita quatro parâmetros, sendo dois opcionais. O parâmetro dims informa qual a dimensão dos dados a serem armazenados no dataset. Para armazenar 25.000 imagens RGB de 256 x 256, deve ser passado (25000, 256, 256, 3).

O parâmetro output_path informa onde salvar o arquivo contendo o dataset hdf5 no computador.

O terceiro parâmetro data_key representa o nome do dataset que vai armazenar as imagens raw. Opcional, passa a string imagens por default.

Por fim, o último parâmetro buffer_size é o valor do buffer. Cada vez que esse buffer é atingido, as imagens saem da memória do computador e são escritas no disco. Por padrão, cada vez que atinge-se 500 imagens armazenadas, é chamado o método flush() para esvaziar o buffer.

Ao instanciar um objeto, o construtor verifica se o arquivo já existe para impedir que este seja apagado ou danificado. Estando tudo certo, é criado um arquivo com o nome passado em output_path, e após são criados dois dataset dentro do mesmo arquivo:

  1. Um que armazenará as imagens raw (Linha 31); e
  2. Um que armazenará os labels de cada imagem (Linha 32).

Na sequência, são criados o buffer, em formato dicionário e um controle self.idx para o algoritmo saber qual a próxima linha que deve ser escrita. Assim não corremos o risco de perder o controle e escrever em alguma linha que já continha dados.

Método para armazenar os labels das classes

No dataset que está armazenando os labels respectivos a cada imagem, é possível encontrar apenas o valor 1 caso a imagem seja de um cachorro e 0 para gatos.

É interessante armazenar em um outro dataset a “decodificação” do que representam esses números, ou seja, o nome das classes dos labels (0 = "cat"; 1 = "dog"):

    def store_class_labels(self, class_labels):
        """
        Cria um dataset para armazenar as classes dos labels.
        :param class_labels: lista com todos nomes das classes dos labels
        """
        dt = h5py.special_dtype(vlen=str)
        label_set = self.db.create_dataset("label_names",
                                           shape=(len(class_labels),),
                                           dtype=dt)
        label_set[:] = class_labels

Método para adicionar mais imagens e labels ao dataset

Esse é o método responsável para adicionar novas linhas nos datasets de imagens e labels, respectivamente. Aqui a gente pode ver o buffer em ação – e valorizar o seu trabalho 🙂

    def add(self, rows, labels):
        """
        Adiciona as linhas e labels ao buffer.
        :param rows: linhas a serem adicionadas ao dataset
        :param labels: labels correspondentes às linhas adicionadas
        """
        self.buffer["data"].extend(rows)
        self.buffer["labels"].extend(labels)
        # verificar se o buffer precisa ser limpo (escrever
        # os dados informados no disco)
        if len(self.buffer["data"]) >= self.buffer_size:
            self.flush()

Todos os arrays passados nos parâmetros são armazenados em uma lista. A cada chamada do método, ele verifica se o tamanho do buffer está extrapolando o valor definido. Caso esteja acima do self.buffer_size, é chamado o método flush().

Método flush para esvaziar buffer e escrever no arquivo HDF5

Como explicado acima, para evitar estourar a memória do computador, quando é atingido um valor limite, o método aqui esvazia o buffer e transcreve as informações para o disco, no arquivo HDF5 que foi gerado:

    def flush(self):
        """Reseta o buffer e escreve os dados no disco."""
        i = self.idx + len(self.buffer["data"])
        self.data[self.idx:i] = self.buffer["data"]
        self.labels[self.idx:i] = self.buffer["labels"]
        self.idx = i
        self.buffer = {"data": [], "labels": []}

Finalizando o arquivo HDF5

Por fim, mas não menos importante, um método para fechar nosso arquivo HDF5, mas não sem antes verificar se alguma imagem ficou esquecida no buffer:

    def close(self):
        """
        Fecha o dataset após verificar se ainda há algum dado
        remanescente no buffer.
        """
        if len(self.buffer["data"]) > 0:
            self.flush()
        # fechar o dataset
        self.db.close()

Construindo um dataset HDF5

Pronto! A nossa classe já está pronta e totalmente funcional, podendo ser usada nos mais diversos tipos de projetos. Para mostrar como usá-la para armazenar imagens, vou usar o dataset Dogs vs. Cats mencionado logo no começo do artigo.

Não vou me aprofundar nos detalhes do código que virá a seguir, pois não é este o objetivo principal do post. Porém, vamos destacar alguns pontos:

# argumentos de entrada do script
ap = argparse.ArgumentParser()
ap.add_argument('-d', '--dataset', required=True,
                help='caminho do dataset')
ap.add_argument('-o', '--output', required=True, default="./tempo.hdf5",
                help='caminho para salvar o arquivo HDF5')
ap.add_argument('-s', '--buffer-size', type=int, default=500,
                help='buffer para escrever no arquivo HDF5')
args = vars(ap.parse_args())

# armazenar o buffer size
bs = args["buffer_size"]

# importar os nomes dos arquivos das imagens
print("[INFO] carregando imagens...")
imagePaths = list(paths.list_images(args["dataset"]))

# extrair e codificar os labels das classes de cada imagem do dataset
labels = [p.split(os.path.sep)[-1].split(".")[0] for p in imagePaths]
le = LabelEncoder()
labels = le.fit_transform(labels)

Nas Linhas 87-94 são estabelecidos os argumentos que o usuário deve informar na linha de comando ao executar o script.

Na Linha 100, usando paths.list_images() a gente consegue extrair para uma lista o caminho de todas fotos. Na sequência, são extraídos os labels para cada uma das imagens (lembre-se que os nomes dos arquivos seguem um padrão, então é só usar str.split à vontade!) para em seguida serem codificados com o auxílio da classe LabelEncoder do pacote sklearn.

Neste momento, chega finalmente a hora de criar o nosso dataset HDF5. Dependendo do tamanho e quantidade de dados a serem processados e importados, este processo pode demorar muito (principalmente se você não está usando uma GPU):

# iniciar o HDF5 e armazenar os nomes dos labels
dataset = HDF5Dataset((len(imagePaths), 256, 256, 3), args["output"], buffer_size=bs)
dataset.store_class_labels(le.classes_)
# Barra de progresso para acopanhar
widgets = ["[imagens] -> [hdf5]: ", progressbar.Percentage(), " ",
           progressbar.Bar(), " ", progressbar.ETA()]
pbar = progressbar.ProgressBar(maxval=len(imagePaths),
                               widgets=widgets).start()

Detalhe importante!! Eu não estou fazendo nenhum pré-processamento importante nas imagens! Aqui, eu apenas redimensionei cada imagem para o shape (256, 256, 3), pois o objetivo era mostrar como importar imagens para arquivos HDF5.

Caso estivéssemos buscando desempenho e precisão para nossas CNN, seriam necessárias várias preocupações, como normalização, tipo de redimensionamento usado (aspect ratio?), necessidade de gerar mais dados de treino (data augmentation), entre outras.

Bom, para acompanhar o (lento) processo, entre as Linhas 113-116 foi gerada um barra de progresso, que irá informando a porcentagem de imagens já importadas e o tempo remanescente do processo.

Por fim, vamos criar um loop para importar cada imagem + label do conjunto de dados do Kaggle:

#  processar e importar as imagens e labels
for (i, (path, label)) in enumerate(zip(imagePaths, labels)):
    image = cv2.imread(path)
    image = cv2.resize(image, (256, 256), interpolation=cv2.INTER_AREA)
    dataset.add([image], [label])
    pbar.update(i)

# finalizar e fechar o arquivo HDF5
pbar.finish()
dataset.close()

De maneira simples, usei a biblioteca OpenCV para ler e redimensionar cada imagem. A cada iteração é chamado o método HDF5Data.add, que joga as imagens no buffer até o limite de self.buffer_size ser atingido.

Atingido o limite do buffer, é chamado o método HDF5Data.flush para escrever as imagens no arquivo do disco e esvaziar o buffer.

Por fim, o arquivo é fechado e temos à disposição um arquivo com facilidade de acesso/fatiamento e super eficiente.

Executando o script

Com todo o código implementado no mesmo arquivo, vamos executar o script digitando o seguinte comando no Shell:

carlos$ python data_hdf5.py --dataset dataset/train/ --output ./train_dataset.hdf5
 [INFO] carregando imagens…
 [imagens] -> [hdf5]: 100% |#####################################| Time: 0:02:19

Simples assim, todas as imagens estão eficientemente armazenadas em uma estrutura muito usada em DL, o formato HDF5.

Para abrir o arquivo e acessar suas fotos, é só importar o pacote h5py e abrir o arquivo em formato de leitura usando
db = h5py.File(“./nome_do_arquivo.hdf5”, “r”)

Para acessar a primeira foto do dataset, é só usar 
db[“imagens”][0]

Para ver o shape do dataset com as images, é só usar
db[“imagens”].shape

E é isso mesmo, exatamente como manipular um array do NumPy.

Tudo maravilhoso? Bem, se você rodou o código, no entanto, com certeza percebeu um “problema”: o tamanho do arquivo gerado!

Antes você tinha um conjunto de imagens que não era cerca de 600 MB, e agora tem um arquivo que chega a “alguns” GB! O que aconteceu?

Resumindo em uma frase: “There is no free lunch!”

O ganho de desempenho e facilidade de manipulação significam que as imagens tiveram que ser  importadas do jeito que elas realmente são, sem nenhum algoritmo de compressão agindo por trás. As imagens foram importadas como raw images, em formato NumPy arrays.

Para trabalharmos em projetos pequenos e poucas imagens, eficiência não é um problema sério. Entretanto, ao avançar mais nesse mundo, é inevitável ter que pensar nos pequenos detalhes do pipeline e da infraestrutura que estamos usando.

Resumo

Neste artigo você teve um contato com o formato HDF5, muito utilizado em projetos acadêmicos e em machine learning. 

Apesar de várias bibliotecas terem seu próprio jeito de lidar com grandes banco de dados e imagens, se você quer eficiência e velocidade, provavelmente vai acabar tendo um contato maior com esse (ou outros) formato de dataset.

Entretanto, essa eficiência não vem de graça: você vai gerar arquivos com vários gigabytes a mais em relação ao dataset original – onde as imagens estavam compactadas por algum tipo de algoritmo. Ao importar imagens como NumPy arrays, você estará trabalhando com raw images.

Não entrei em detalhes, mas a mesma classe serve para armazenar as features extraídas após o treinamento de uma CNN qualquer. Para isso ser feito,  você teria apenas que transformar o output da CNN em vetor (flatten) e prestar atenção nas dimensões a serem informadas na execução do script.

Bem, não tem como aprofundar muito mais no conteúdo e explicações. A ideia é apenas compartilhar coisas que estou aprendendo e que acho que estão sendo úteis para o meu aprendizado.

Se você ficou com alguma dúvida ou plotou algum erro conceitual/código, compartilhe aqui nos comentários! Também estou na batalha para aprender essa área fascinante da deep learning, mas ainda estou no começo da caminhada. Abraços!

Compartilhar3Compartilhar15Enviar
Post Anterior

Redes Neurais Convolucionais com Python

Próximo Post

Data Science: Investigando o naufrágio do Titanic [Pt. 1]

Carlos Melo

Carlos Melo

Engenheiro de Visão Computacional graduado em Ciências Aeronáuticas pela Academia da Força Aérea (AFA) e Mestre em Engenharia Aeroespacial pelo Instituto Tecnológico de Aeronáutica (ITA).

Relacionado Artigos

Por que o ChatGPT mente para você?
Artigos

Por que o ChatGPT mente para você?

por Carlos Melo
setembro 16, 2025
Green Card aprovado por habilidades extraordinárias em Data Science
Blog

Green Card aprovado por habilidades extraordinárias em Data Science

por Carlos Melo
julho 14, 2025
O Que é Amostragem e Quantização no Processamento de Imagens
Artigos

O Que é Amostragem e Quantização no Processamento de Imagens

por Carlos Melo
junho 20, 2025
Curso de Pós-Graduação em Data Science
Data Science

Vale a pena fazer uma Pós-Graduação em Data Science?

por Carlos Melo
janeiro 20, 2025
Review do Livro “Mãos à obra: Aprendizado de Máquina com Scikit-Learn, Keras & TensorFlow”
Livros

Review do Livro “Mãos à obra: Aprendizado de Máquina com Scikit-Learn, Keras & TensorFlow”

janeiro 18, 2025
Próximo Post
Data Science: Investigando o naufrágio do Titanic [Pt. 1]

Data Science: Investigando o naufrágio do Titanic [Pt. 1]

Comentários 1

  1. Evandro Saraiva says:
    5 anos atrás

    Muito legal! Obrigado pelo conhecimento!

    Responder

Deixe um comentário Cancelar resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Pós-Graduação em Data Science Pós-Graduação em Data Science Pós-Graduação em Data Science

Mais Populares

  • Introdução ao MediaPipe e Pose Estimation

    Introdução ao MediaPipe e Pose Estimation

    511 compartilhamentos
    Compartilhar 204 Tweet 128
  • Por que o ChatGPT mente para você?

    9 compartilhamentos
    Compartilhar 4 Tweet 2
  • ORB-SLAM 3: Tutorial Completo para Mapeamento 3D e Localização em Tempo Real

    424 compartilhamentos
    Compartilhar 170 Tweet 106
  • Geometria da Formação de Imagens: Matrizes, Transformações e Sistemas de Coordenadas

    397 compartilhamentos
    Compartilhar 159 Tweet 99
  • Processamento de Nuvens de Pontos com Open3D e Python

    56 compartilhamentos
    Compartilhar 22 Tweet 14
  • Em Alta
  • Comentários
  • Mais Recente
Como Tratar Dados Ausentes com Pandas

Como Tratar Dados Ausentes com Pandas

agosto 13, 2019
Como usar o DALL-E 2 para gerar imagens a partir de textos

Como usar o DALL-E 2 para gerar imagens a partir de textos

dezembro 25, 2022
Introdução ao MediaPipe e Pose Estimation

Introdução ao MediaPipe e Pose Estimation

julho 15, 2023

ORB-SLAM 3: Tutorial Completo para Mapeamento 3D e Localização em Tempo Real

abril 10, 2023
Como Analisar Ações da Bolsa com Python

Como Analisar Ações da Bolsa com Python

15
Setembro Amarelo: Análise do Suicídio no Brasil, com Data Science

Setembro Amarelo: Análise do Suicídio no Brasil, com Data Science

13
Como Aprender Data Science?

Como Aprender Data Science?

9
Qual o Cenário de Data Science no Brasil hoje?

Qual o Cenário de Data Science no Brasil hoje?

8
Por que o ChatGPT mente para você?

Por que o ChatGPT mente para você?

setembro 16, 2025
Green Card aprovado por habilidades extraordinárias em Data Science

Green Card aprovado por habilidades extraordinárias em Data Science

julho 14, 2025
O Que é Amostragem e Quantização no Processamento de Imagens

O Que é Amostragem e Quantização no Processamento de Imagens

junho 20, 2025
DeepSeek vazamento de dados de usuários

DeepSeek: Vazamento de dados expõe dados de usuários

fevereiro 1, 2025

Seguir

  • 💰 Você sabe o que faz e quanto ganha um cientista de dados?

Ser Cientista de Dados significa trabalhar com inteligência artificial, estatística e programação para transformar dados em decisões que movimentam negócios e impactam bilhões de pessoas.

É a função que dá vida a recomendações personalizadas, modelos preditivos e sistemas inteligentes que mudam a forma como empresas inovam.

E não é apenas fascinante...

💼💰 É também uma das carreiras mais bem remuneradas da área de tecnologia!

Se você quer uma carreira com futuro, relevância e excelente retorno financeiro, Data Science é o caminho certo!

#cientistadedados #datascience #python
  • Você colocaria fraldas do lado das cervejas no seu supermercado? 🤔

Parece estranho, mas foi exatamente essa descoberta que mudou as vendas do Walmart.

Os cientistas de dados da empresa analisaram milhões de transações com uma técnica de Data Mining que identifica padrões de compra e combinações inesperadas de produtos.

Então, usando algoritmos da Data Science, cruzaram dados de horário, perfil de cliente e itens comprados juntos.

Encontraram algo curioso: homens que passavam no mercado após as 18h para comprar fraldas, muitas vezes no caminho de casa, também compravam cerveja 🍺.

O Walmart testou a hipótese: colocou fraldas perto da seção de cervejas.

O resultado? As vendas de cerveja dispararam. 🚀

Esse é um exemplo clássico de como Data Science gera impacto direto no negócio.

Não é sobre algoritmos complexos apenas; é sobre transformar dados históricos em decisões inteligentes e lucrativas.

#datascience #cientistadedados #machinelearning
  • Conheça as formações da Academia Sigmoidal.

Nossos programas unem rigor acadêmico, prática aplicada e dupla certificação internacional, preparando você para atuar em Data Science, Visão Computacional e Inteligência Artificial com impacto real no mercado.

🤖 Pós-Graduação em Data Science: Forma Cientistas de Dados e Engenheiros de Machine Learning do zero, com Python, estatística e projetos práticos do mundo real.

👁️ Pós-Graduação em Visão Computacional: Especialize-se em processamento de imagens, Deep Learning, redes neurais e navegação autônoma de drones, tornando-se Engenheiro de Visão Computacional ou Engenheiro de Machine Learning.

📊 MBA em Inteligência Artificial: Voltado a profissionais de qualquer área, ensina a aplicar IA estrategicamente em negócios, usando automação, agentes de IA e IA generativa para inovação e competitividade.

Além do título de Especialista reconhecido pelo MEC, você ainda conquista uma Dupla Certificação Internacional com o STAR Research Institute (EUA).

💬 Interessado em dar o próximo passo para liderar no mercado de tecnologia? Me envie uma mensagem e eu te ajudo pessoalmente com a matrícula.

#DataScience #InteligenciaArtificial #VisaoComputacional
  • Treinar um modelo significa encontrar um bom conjunto de parâmetros. Esse conjunto é definido pela função objetivo, também chamada de função de perda. 👀

O gradient descent é o algoritmo que ajusta esses parâmetros passo a passo. Ele calcula a direção de maior inclinação da função de perda e move o modelo para baixo nessa curva. ⬇️

Se o parâmetro é o peso que multiplica X ou o bias que desloca a reta, ambos são atualizados. Cada iteração reduz o erro, aproximando o modelo da solução ótima.

A intuição é simples: sempre que a função de perda é maior, o gradiente aponta o caminho. O algoritmo segue esse caminho até que não haja mais descida possível. 🔄 

#inteligênciaartificial #datascience #machinelearning
  • Qual a melhor linguagem? PYTHON ou R?

Diretamente do túnel do tempo! Resgatei esse vídeo polêmico de 2021, quem lembra??

#DataScience #Python #R #Programação
  • 🎥 Como começar uma CARREIRA como CIENTISTA DE DADOS

Você já pensou em entrar na área que mais cresce e que paga os melhores salários no mundo da tecnologia?

Domingo você vai descobrir o que realmente faz um Cientista de Dados, quais são as habilidades essenciais e o passo a passo para dar os primeiros passos na carreira.

Eu vou te mostrar um mapa para você sair do zero e se preparar para trabalhar com Data Science em 2026.

📅 Domingo, 28 de setembro
🕖 20:00h (horário de Brasília)
🔗 Link nos Stories

Clique no link dos Stories e receba o link da aula ao vivo!

#datascience #machinelearning #cientistadedados
  • VISÃO COMPUTACIONAL está no centro de um dos avanços mais impressionantes da exploração espacial recente: o pouso autônomo da missão Chang’e-5 na Lua. 🚀🌑

Durante a descida, câmeras de alta resolução e sensores a laser capturavam continuamente o relevo lunar, enquanto algoritmos embarcados processavam as imagens em tempo real para identificar crateras e obstáculos que poderiam comprometer a missão.

Esses algoritmos aplicavam técnicas de detecção de bordas e segmentação, aproximando crateras por elipses e cruzando a análise visual com dados de altímetros. Assim, a IA conseguia selecionar regiões planas e seguras para o pouso, ajustando a trajetória da nave de forma autônoma. 

Esse processo foi indispensável, já que a distância entre Terra e Lua gera atraso de comunicação que inviabiliza controle humano direto em tempo real.

Esse caso ilustra como IA embarcada está deixando de ser apenas uma ferramenta de análise pós-missão para se tornar parte crítica das operações espaciais autônomas em tempo real — um passo essencial para missões em Marte, asteroides e no lado oculto da Lua.

(PS: Vi o Sérgio Sacani, do @spacetoday , postando isso primeiro.)

#visaocomputacional #machinelearning #datascience
  • 🔴Aprenda a MATEMÁTICA por Trás do MACHINE LEARNING

Você já se perguntou como as máquinas aprendem?🤖 

A resposta está na matemática que dá vida ao Machine Learning. E neste vídeo, você vai aprender os conceitos fundamentais que sustentam os algoritmos de inteligência artificial, de forma clara e acessível.

Mais do que apenas fórmulas, a ideia é mostrar como cada peça matemática se conecta para transformar dados em aprendizado. Se você deseja compreender a lógica por trás do funcionamento das máquinas, essa aula é um ótimo ponto de partida.

📅 Domingo, 21 de setembro
🕖 20:00h (horário de Brasília)
🔗 Link nos Stories

#machinelearning #datascience #cientistadedados
  • 🚀 As matrículas estão abertas!
Depois de quase 1 ano, a nova turma da Pós-Graduação em Data Science chegou.

NOVIDADE: agora com Dupla Certificação Internacional:
🇧🇷 Diploma de Especialista reconhecido pelo MEC
🇺🇸 Certificado do STAR Research Institute (EUA)

Aprenda Data Science na prática, domine Machine Learning e IA, e conquiste reconhecimento no Brasil e no mundo.

2025 pode ser o ano em que você dá o passo decisivo para se tornar Cientista de Dados.

🔗 Clique no link da bio e reserve sua vaga!
#datascience #cienciadedados #python
  • Por que o CHATGPT MENTE PARA VOCÊ? 🤔

Já percebeu que o ChatGPT às vezes responde com confiança... mas está errado? 

Isso acontece porque, assim como um aluno em prova, ele prefere chutar do que deixar em branco.
Essas respostas convincentes, mas erradas, são chamadas de alucinações.

E o que o pesquisadores da OpenAI sugerem, é que esse tipo de comportamento aparece porque os testes que treinam e avaliam o modelo premiam o chute e punem a incerteza.

Então, da próxima vez que ele ‘inventar’ algo, lembre-se: não é pessoal, ele apenas for treinado dessa maneira!
#inteligênciaartificial #chatgpt #datascience
  • ChatGPT: um "estagiário de LUXO" para aumentar sua produtividade na programação.

 #programacao #copiloto #produtividade #streamlit #dashboard #tecnologia #devlife
  • Da série “Foi a IA que me deu”, vamos relembrar minha viagem pra Tromsø, na Noruega, 500 km acima da linha do Círculo Polar Ártico. 🌍❄️

No vídeo de hoje, você vai aprender o que é um "fiorde"! 

Como você dormia sem saber o que era um fiorde?? 😅
  • Qual LINGUAGEM DE PROGRAMAÇÃO é usada na TESLA?

A Tesla utiliza diferentes linguagens de programação em cada fase do ciclo de desenvolvimento. 

O treinamento das redes neurais convolucionais (CNN) é feito em Python, aproveitando bibliotecas científicas e a rapidez de prototipagem. Isso permite testar arquiteturas de CNN com agilidade no ambiente de pesquisa.

Já a implementação embarcada ocorre em C++, garantindo alta performance. Como os modelos de CNN precisam responder em tempo real, o C++ assegura baixa latência para tarefas como detectar pedestres e interpretar placas de trânsito.

Com isso, a Tesla combina Python para pesquisa e C++ para produção, equilibrando inovação e velocidade em sistemas críticos de visão computacional.

#python #machinelearning #inteligenciaartificial
  • Aproveitando o domingo… vamos relaxar um pouco e falar sobre cinema 🎬

Em
  • Já se perguntou como conseguimos distinguir intuitivamente um gato de um cachorro, mesmo com tantas semelhanças físicas? 

Para nós, essa identificação é quase automática.

Na filosofia aristotélica, a inteligência é um atributo da alma: o mundo real é captado pelos sentidos, transformado em imagens na imaginação (fantasmas), e organizado em conceitos que nos permitem compreender a realidade de forma imediata.

Já as máquinas não têm alma nem intuição. Para aprender essa mesma tarefa, precisam decompor o problema em camadas hierárquicas: 

Nas primeiras, redes neurais profundas extraem padrões simples (bordas, texturas); nas intermediárias, formas mais abstratas (orelhas, olhos, focinho); e apenas nas finais esses elementos são combinados em conceitos de alto nível como “gato” ou “cachorro”.

Enquanto nós chegamos ao entendimento de forma direta, a inteligência artificial depende de sucessivas representações para “fazer sentido” do mundo. 🤖

#inteligênciaartificial #redesneurais #deepLearning #filosofia #tecnologia
  • INTELIGÊNCIA ARTIFICIAL se tornou a carreira mais promissora atualmente.

Este mercado, em constante crescimento global, oferece oportunidades de trabalho remoto, seja como freelancer ou contratado por empresas. 

Para quem busca uma carreira flexível e em expansão, a área de DATA SCIENCE / IA pode ser o caminho ideal. 

Afinal, você consgue me dizer quais outras áreas oferecem tamanha versatilidade e crescimento? 

#cienciadedados #python #inteligenciaartificial #mercadodetrabalho #tecnologia #oportunidades
Instagram Youtube LinkedIn Twitter
Sigmoidal

O melhor conteúdo técnico de Data Science, com projetos práticos e exemplos do mundo real.

Seguir no Instagram

Categorias

  • Aeroespacial
  • Artigos
  • Blog
  • Carreira
  • Cursos
  • Data Science
  • Deep Learning
  • Destaques
  • Entrevistas
  • IA Generativa
  • Livros
  • Machine Learning
  • Notícias
  • Python
  • Teoria
  • Tutoriais
  • Visão Computacional
  • Youtube

Navegar por Tags

camera calibration carreira chatgpt cientista de dados cnn computer vision Cursos dados desbalanceados data science data science na prática decision tree deep learning gpt-3 histograma IA generativa image formation inteligência artificial jupyter kaggle keras machine learning matplotlib mnist nft openai opencv overfitting pandas profissão python redes neurais redes neurais convolucionais regressão linear regressão logística salário scikit-learn seaborn sklearn tensorflow titanic tutorial visão computacional vídeo youtube árvore de decisão

© 2024 Sigmoidal - Aprenda Data Science, Visão Computacional e Python na prática.

Welcome Back!

Login to your account below

Forgotten Password?

Retrieve your password

Please enter your username or email address to reset your password.

Log In

Add New Playlist

Sem Resultado
Ver Todos Resultados
  • Home
  • Cursos
  • Pós-Graduação
  • Blog
  • Sobre Mim
  • Contato
  • English

© 2024 Sigmoidal - Aprenda Data Science, Visão Computacional e Python na prática.