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
37
COMPARTILHAMENTOS
1.2k
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

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
Carlos Melo e Sérgio Sacani – Ciência Sem Fim
Youtube

Carlos Melo e Sérgio Sacani – Ciência Sem Fim

por Carlos Melo
janeiro 16, 2025
Carlos Melo da Pós Graduação em Data Science do Sigmoidal
Aeroespacial

Oportunidades no Setor Espacial para Cientistas de Dados

por Carlos Melo
janeiro 15, 2025
Visão Computacional

Processamento de Nuvens de Pontos com Open3D e Python

por Carlos Melo
janeiro 2, 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

    450 compartilhamentos
    Compartilhar 180 Tweet 113
  • Equalização de Histograma com OpenCV e Python

    112 compartilhamentos
    Compartilhar 45 Tweet 28
  • ORB-SLAM 3: Tutorial Completo para Mapeamento 3D e Localização em Tempo Real

    385 compartilhamentos
    Compartilhar 154 Tweet 96
  • Geometria da Formação de Imagens: Matrizes, Transformações e Sistemas de Coordenadas

    368 compartilhamentos
    Compartilhar 147 Tweet 92
  • Redes Neurais Convolucionais com Python

    92 compartilhamentos
    Compartilhar 37 Tweet 23
  • 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
DeepSeek vazamento de dados de usuários

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

fevereiro 1, 2025
DeepSeek R1 vs OpenAI o1 – Qual é o Melhor Modelo de IA

DeepSeek R1 vs OpenAI o1 – Qual é o Melhor Modelo de IA?

janeiro 25, 2025
Trump Anuncia Investimento de US$ 500 Bilhões em Infraestrutura de IA

Trump Anuncia Investimento de US$ 500 Bilhões em Infraestrutura de IA

janeiro 22, 2025
Trump revoga decreto de Biden sobre regulação de Inteligência Artificial

Trump revoga decreto de Biden sobre regulação de Inteligência Artificial

janeiro 21, 2025

Seguir

  • 🇺🇸 Green Card por Habilidade Extraordinária em Data Science e Machine Learning

Após nossa mudança para os EUA, muitas pessoas me perguntaram como consegui o Green Card tão rapidamente. Por isso, decidi compartilhar um pouco dessa jornada.

O EB-1A é um dos vistos mais seletivos para imigração, sendo conhecido como “The Einstein Visa”, já que o próprio Albert Einstein obteve sua residência permanente através desse processo em 1933.

Apesar do apelido ser um exagero moderno, é fato que esse é um dos vistos mais difíceis de conquistar. Seus critérios rigorosos permitem a obtenção do Green Card sem a necessidade de uma oferta de emprego.

Para isso, o aplicante precisa comprovar, por meio de evidências, que está entre os poucos profissionais de sua área que alcançaram e se mantêm no topo, demonstrando um histórico sólido de conquistas e reconhecimento.

O EB-1A valoriza não apenas um único feito, mas uma trajetória consistente de excelência e liderança, destacando o conjunto de realizações ao longo da carreira.

No meu caso específico, após escrever uma petição com mais de 1.300 páginas contendo todas as evidências necessárias, tive minha solicitação aprovada pelo USCIS, órgão responsável pela imigração nos Estados Unidos.

Fui reconhecido como um indivíduo com habilidade extraordinária em Data Science e Machine Learning, capaz de contribuir em áreas de importância nacional, trazendo benefícios substanciais para os EUA.

Para quem sempre me perguntou sobre o processo de imigração e como funciona o EB-1A, espero que esse resumo ajude a esclarecer um pouco mais. Se tiver dúvidas, estou à disposição para compartilhar mais sobre essa experiência! #machinelearning #datascience
  • 🚀Domine a tecnologia que está revolucionando o mundo.

A Pós-Graduação em Visão Computacional & Deep Learning prepara você para atuar nos campos mais avançados da Inteligência Artificial - de carros autônomos a robôs industriais e drones.

🧠 CARGA HORÁRIA: 400h
💻 MODALIDADE: EAD
📅 INÍCIO DAS AULAS: 29 de maio

Garanta sua vaga agora e impulsione sua carreira com uma formação prática, focada no mercado de trabalho.

Matricule-se já!

#deeplearning #machinelearning #visãocomputacional
  • Green Card aprovado! 🥳 Despedida do Brasil e rumo à nova vida nos 🇺🇸 com a família!
  • Haverá sinais… aprovado na petição do visto EB1A, visto reservado para pessoas com habilidades extraordinárias!

Texas, we are coming! 🤠
  • O que EU TENHO EM COMUM COM O TOM CRUISE??

Clama, não tem nenhuma “semana” aberta. Mas como@é quinta-feira (dia de TBT), olha o que eu resgatei!

Diretamente do TÚNEL DO TEMPO: Carlos Melo &Tom Cruise!
  • Bate e Volta DA ITÁLIA PARA A SUÍÇA 🇨🇭🇮🇹

Aproveitei o dia de folga após o Congresso Internacional de Astronáutica (IAC 2024) e fiz uma viagem “bate e volta” para a belíssima cidade de Lugano, Suíça.

Assista ao vlog e escreve nos comentários se essa não é a cidade mais linda que você já viu!

🔗 LINK NOS STORIES
  • Um paraíso de águas transparentes, e que fica no sul da Suíça!🇨🇭 

Conheça o Lago de Lugano, cercado pelos Alpes Suíços. 

#suiça #lugano #switzerland #datascience
  • Sim, você PRECISA de uma PÓS-GRADUAÇÃO em DATA SCIENCE.
  • 🇨🇭Deixei minha bagagem em um locker no aeroporto de Milão, e vim aproveitar esta última semana nos Alpes suíços!
  • Assista à cobertura completa no YT! Link nos stories 🚀
  • Traje espacial feito pela @axiom.space em parceria com a @prada 

Esse traje será usados pelos astronautas na lua.
para acompanhar as novidades do maior evento sobre espaço do mundo, veja os Stories!

#space #nasa #astronaut #rocket
  • INTERNATIONAL ASTRONAUTICAL CONGRESS - 🇮🇹IAC 2024🇮🇹

Veja a cobertura completa do evento nos DESTAQUES do meu perfil.

Esse é o maior evento de ESPAÇO do mundo! Eu e a @bnp.space estamos representando o Brasil nele 🇧🇷

#iac #space #nasa #spacex
  • 🚀 @bnp.space is building the Next Generation of Sustainable Rocket Fuel.

Join us in transforming the Aerospace Sector with technological and sustainable innovations.
  • 🚀👨‍🚀 Machine Learning para Aplicações Espaciais

Participei do maior congresso de Astronáutica do mundo, e trouxe as novidades e oportunidade da área de dados e Machine Learning para você!

#iac #nasa #spacex
  • 🚀👨‍🚀ACOMPANHE NOS STORIES

Congresso Internacional de Astronáutica (IAC 2024), Milão 🇮🇹
  • Projeto Aeroespacial do final de semana!👨‍🚀
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.