fbpx
Sigmoidal
  • Home
  • CursosNOVO
  • Sobre Mim
  • Contato
Sem Resultado
Ver Todos Resultados
  • Home
  • CursosNOVO
  • Sobre Mim
  • Contato
Sem Resultado
Ver Todos Resultados
Sigmoidal
Sem Resultado
Ver Todos Resultados
Home Artigos Machine Learning

Armazenamento de grandes quantidades de dados com HDF5

Carlos Melo por Carlos Melo
julho 4, 2019
em Machine Learning
1
Armazenamento de grandes quantidades de dados com HDF5
21
COMPARTILHAMENTOS
696
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!

Tags: big datacnndeep learninghdf5machine learningpythonredes neuraisredes neurais convolucionais
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

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

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

por Carlos Melo
dezembro 25, 2022
Como a França usou Inteligência Artificial para detectar 20 mil piscinas
Deep Learning

Como a França usou Inteligência Artificial para detectar 20 mil piscinas

por Carlos Melo
dezembro 19, 2022
ChatGPT: A Inteligência Artificial que vai escrever seus códigos
Artigos

ChatGPT: A Inteligência Artificial que vai escrever seus códigos

por Carlos Melo
dezembro 18, 2022
7 livros essenciais para aprender Data Science em 2023
Artigos

7 livros essenciais para aprender Data Science em 2023

por Carlos Melo
dezembro 15, 2022
Como a banda Metallica usa Data Science
Artigos

Como a banda Metallica usa Data Science

por Carlos Melo
novembro 15, 2022
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. Avatar Evandro Saraiva says:
    3 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 *

Destaques Sigmoidal

NFT e artes criadas por Inteligência Artificial

NFT e artes criadas por Inteligência Artificial

junho 17, 2022
Detector de Fadiga usando Python

Detector de Fadiga usando Python

outubro 6, 2020
Visão Computacional do zero até uma vaga no exterior

Visão Computacional do zero até uma vaga no exterior

abril 22, 2021
Especialização em Visão Computacional Especialização em Visão Computacional Especialização em Visão Computacional

Seguir

  • Camera Tracking, Reconstrução 3D e a Arte da Visão 🎥👁️‍🗨️

O “camera tracking” é uma técnica que permite a análise e reprodução do movimento da câmera em filmagens 2D. 

Esta análise fornece dados vitais sobre a posição e orientação da câmera ao longo do tempo, sendo essencial para a integração de elementos 3D virtuais em visuais 2D. 

A minha jornada acadêmica levou-me ao coração da engenharia de visão computacional, onde explorei tópicos cruciais como lens distortion, camera calibration e image processing. Dediquei-me a técnicas avançadas, abrangendo desde a utilização de filtros Gaussianos, conversão de imagens para grayscale até algoritmos de keypoint detection. 

No decorrer de meus estudos, tive a chance de trabalhar com métodos clássicos, como “Harris Corner Detection”, e também com abordagens mais contemporâneas como ORB, além de descritores como SIFT, SURF e BRISK.

Mas apesar da minha formação predominantemente técnica, centrada no mundo dos modelos quantitativos e da modelagem matemática, identifiquei um diferencial valioso na trilha da visão computacional.

🎨 Esse diferencial foi a capacidade de não se limitar apenas ao lado técnico. Ao contrário, busquei uma fusão entre a precisão técnica e a sensibilidade artística.

Compreendi que a verdadeira inovação surge quando se une o rigor técnico à visão criativa. Nessa intersecção, a arte e a ciência dançam juntas, produzindo resultados que são ao mesmo tempo precisos e emocionalmente impactantes.

Como o escritor A. D. Sertillanges expressou tão eloquentemente, nossa vocação como seres humanos exige que primeiro estejamos profundamente enraizados em nossa humanidade, viajando com confiança e solidez:

💬 “Toda ciência, quando cultivada isoladamente, não é apenas incompleta, mas também repleta de riscos.”

Serve como um lembrete constante de que dentro de cada tarefa computacional e linha de código existe uma miríade de histórias, prontas para serem reveladas e compartilhadas. 

#machinelearning #visãocomputacional
  • 🤖Você já testou essa ferramenta? 

Prece mentira, mas você pode gravar um vídeo seu agora mesmo, e subir nesse site para ele dublar para inglês e várias outras línguas! 🇺🇸🇪🇸🇧🇷🇩🇪

E não apenas isso! Ele sincroniza inclusive os seus lábios para ficar o mais real possível. 

O que você achou? Que tal testar agora mesmo e me mandar?

#machinelearning #inteligenciaartificial
  • ‘Eu nasci assim, eu cresci assim, vou sempre usar arquivos CSV…’ 🎶

Será mesmo? Se a síndrome de Gabriela te prende aos antigos e gigantes arquivos CSV, é hora de repensar! 🤔

Calma, não me entenda mal. Eu uso arquivos CSV para muitas coisas, mesmo! Mas permita-me apresentar um formato que já é bem conhecido pelos engenheiros de dados, mas que, por algum motivo, ainda não é muito famoso entre os cientistas de dados.

O principal problema do CSV é sua estrutura. Eles são armazenados como uma lista de linhas (conhecido como orientado a linhas), o que causa duas grandes complicações: eles são lentos para consultar e, para complicar ainda mais, SQL e CSV simplesmente não se dão bem.

Agora, entre em cena o Parquet: um formato orientado a colunas. Diferentemente dos CSVs, ele organiza seus dados por colunas, o que facilita e agiliza a consulta.

Além disso, é um formato de código aberto, licenciado sob Apache, o que o torna uma opção atrativa não apenas pela sua eficiência, mas também pela flexibilidade e transparência. Engenheiros de dados já se beneficiam das vantagens do Parquet há algum tempo, então por que os cientistas de dados não dariam uma chance também?

Se você é um cientista de dados e ainda não experimentou o Parquet, talvez seja o momento de se aventurar. E aí, já conhecia essa alternativa? Deixe seus comentários! 🚀

#machinelearning #datascience  #visaocomputacional
  • Eu não aprendi a estudar do dia para a noite.

Foram anos de aprimoramento e busca contínua por um método que me permitisse aprender qualquer coisa sozinho.

Nessa sequência de stories eu conto um pouco da minha trajetória, passando pela AFA, ITA e aprendizado de línguas. 

Se você ainda não tem o hábito da leitura, mas gostaria de aprender qualquer coisa rapidamente, como autodidata, você não pode perder a live de hoje. 

🔴AULA AO VIVO (hoje, às 20 horas)

✅Como criar uma rotina de estudo
✅Como criar resumos e notas de revisão
✅Como manter o foco e a concentração
✅Técnicas de Ultra-Aprendizado

Clique no link dos stories e ative a notificação da aula!
  • 📚Ao contrário do que o senso comum pode te induzir a pensar, você não pode querer apenas estudar livros técnicos. 

Ler e memorizar demandam a construção de múltiplas habilidades em diferentes dimensões. Afinal, você precisa crescer não apenas na vida profissional, mas também na humana, espiritual e familiar. 

No entanto, a escolha de livros errados podem prejudicar perigosamente a formação do conhecimento intelectual.

Por esse motivo, aqui vai uma sugestão de livros para aqueles que querem começar uma vida de estudos. 

E se você quiser aprender mais sobre como melhorar sua memória, elaborar resumos da maneira correta e manter o foco na leitura, mande uma mensagem por direct com a palavra “ESTUDO”. 

Depois que você enviar a palavra “estudo”, eu vou te encaminhar o link da aula exclusiva que eu farei sobre o assunto. 

Agora me diz, quais desses livros você já leu? Ou está na fila para leitura?

#leitura #estudos #machinelearning #computervision
  • ORB-SLAM é um sistema SLAM (Localização e Mapeamento Simultâneos) de última geração que utiliza uma combinação de métodos baseados em características e métodos diretos para alcançar desempenho em tempo real em diversas plataformas. Foi concebido por pesquisadores da Universidade de Zaragoza, Espanha, e agora é amplamente adotado tanto na academia quanto na indústria.

O nome ORB-SLAM deriva do seu uso de características Oriented FAST e Rotated BRIEF (ORB) para detectar e combinar pontos-chave em imagens. Essas características, juntamente com outras técnicas como fechamento de loop e otimização de pose, garantem uma localização e mapeamento robustos e precisos.

Graças à sua combinação de métodos baseados em características e diretos, juntamente com suas capacidades em tempo real e compatibilidade versátil de plataforma, ORB-SLAM destaca-se como um recurso inestimável para profissionais em visão computacional e robótica.

Ansioso para aprender como implementar o ORB-SLAM 3, desde sua instalação até a execução do sistema usando seus dados? Acesse o blog do sigmoidal e veja o tutorial com o passo a passo que eu preparei.

https://sigmoidal.ai

#visãocomputacional #machinelearning #slam #opencv
  • Filhos não são um direito, mas um dom de Deus. E hoje fomos abençoados com o nascimento da Bettina. 

Já te amamos muito, minha Pycotinha!
  • Sorria, você está sendo filmado (e analisado pela Visão Computacional)! Estimação de velocidade, fluxo óptico de pedestres e veículos, identificação de objetos abandonados, análise de comportamentos, cruzamento de dados com a base da polícia... quais outras possibilidades você enxerga?
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

  • Artigos
  • Blog
  • Carreira
  • Colunistas
  • Cursos
  • Data Science
  • Deep Learning
  • Destaques
  • Entrevistas
  • Inglês
  • Iniciantes
  • Inteligência Artificial
  • Livros
  • Machine Learning
  • Notícias
  • Outros
  • Projetos
  • Python
  • Teoria
  • Tutoriais
  • Visão Computacional
  • Youtube

Navegar por Tags

camera calibration cancer carreira cientista de dados cnn computer vision Cursos dados desbalanceados data science data science na prática decision tree deep learning gis gpt-3 healthcare image formation iniciantes jupyter kaggle keras machine learning matplotlib medicina mnist nft opencv pandas personal branding portfólio profissão python redes neurais redes neurais convolucionais regressão logística salário seaborn sklearn tensorflow titanic tutorial vagas visão computacional vídeo youtube árvore de decisão

© 2023 Sigmoidal - Aprenda Data Science e Python na prática.

Sem Resultado
Ver Todos Resultados
  • Home
  • Cursos de Visão Computacional, Data Science e Python
  • Artigos
  • YouTube
  • Sobre Mim
  • Contato

© 2023 Sigmoidal - Aprenda Data Science 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

Aprenda Python do Zero

50% Off

Oferta exclusiva de aniversário do Sigmoidal. Inscreva-se no curso Python do Zero hoje mesmo.

QUERO APROVEITAR O DESCONTO