fbpx
Sigmoidal
  • Home
  • Data Science
    Data Science no exterior - como fazer uma Cover Letter

    Como escrever uma Cover Letter poderosa para Data Science

    GESTÃO DE DADOS: aprenda Data Science ou pague o preço de uma decisão errada | PrimoCast com Thiago Nigro

    Aprenda Data Science ou pague o preço de uma decisão errada

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

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

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

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

    7 livros essenciais para aprender Data Science em 2023

    7 livros essenciais para aprender Data Science em 2023

    Como a banda Metallica usa Data Science

    Como a banda Metallica usa Data Science

    Entrevista com Rodrigo Gianotto, CTO do Grupo Primo

    Entrevista com Rodrigo Gianotto, CTO do Grupo Primo

    Use a estratégia da Apollo 13 para conseguir uma vaga no mercado

    Use a estratégia da Apollo 13 para conseguir uma vaga no mercado

    Python para análise de ações e investimentos

    Python para análise de ações e investimentos

    Gerando amostras para modelos de Deep learning no ArcGIS Pro

    Gerando amostras para modelos de Deep learning no ArcGIS Pro

    7 Livros de Data Science em 2021

    7 Livros de Data Science em 2021

    Quanto ganha um Cientista de Dados?

    Quanto ganha um Cientista de Dados?

    Trending Tags

    • Python
      Fundamentos da Formação da Imagem

      Fundamentos da Formação da Imagem

      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

      aprenda python do zero - curso gratuito

      Projeto Python: um plano à prova de desculpas

      Entrevista com Rodrigo Gianotto, CTO do Grupo Primo

      Entrevista com Rodrigo Gianotto, CTO do Grupo Primo

      Projeto Python do Zero: evento 100% gratuito

      Projeto Python do Zero: evento 100% gratuito

      Aprenda Python e se destaque no mercado

      Aprenda Python e se destaque no mercado

      Python para análise de ações e investimentos

      Python para análise de ações e investimentos

      Como fazer gráficos rotulados em Python

      Como fazer gráficos rotulados em Python

      Trabalhando com Dados Desbalanceados

      Trabalhando com Dados Desbalanceados

      Trending Tags

      • Visão Computacional
        Fundamentos da Formação da Imagem

        Fundamentos da Formação da Imagem

        Como usar OpenCV e Python para calibrar câmeras

        Como usar OpenCV e Python para calibrar câmeras

        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

        Crie um sistema de vigilância com drones e Deep Learning

        Crie um sistema de vigilância com drones e Deep Learning

        Detector de Fadiga usando Python

        Detector de Fadiga usando Python

        Redes Neurais Convolucionais com Python

        Redes Neurais Convolucionais com Python

        Reduzindo o Overfitting com Data Augmentation

        Reduzindo o Overfitting com Data Augmentation

        Redes Neurais Multicamadas com Python e Keras

        Redes Neurais Multicamadas com Python e Keras

        Trending Tags

        • Sobre Mim
        No Result
        View All Result
        • Home
        • Data Science
          Data Science no exterior - como fazer uma Cover Letter

          Como escrever uma Cover Letter poderosa para Data Science

          GESTÃO DE DADOS: aprenda Data Science ou pague o preço de uma decisão errada | PrimoCast com Thiago Nigro

          Aprenda Data Science ou pague o preço de uma decisão errada

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

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

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

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

          7 livros essenciais para aprender Data Science em 2023

          7 livros essenciais para aprender Data Science em 2023

          Como a banda Metallica usa Data Science

          Como a banda Metallica usa Data Science

          Entrevista com Rodrigo Gianotto, CTO do Grupo Primo

          Entrevista com Rodrigo Gianotto, CTO do Grupo Primo

          Use a estratégia da Apollo 13 para conseguir uma vaga no mercado

          Use a estratégia da Apollo 13 para conseguir uma vaga no mercado

          Python para análise de ações e investimentos

          Python para análise de ações e investimentos

          Gerando amostras para modelos de Deep learning no ArcGIS Pro

          Gerando amostras para modelos de Deep learning no ArcGIS Pro

          7 Livros de Data Science em 2021

          7 Livros de Data Science em 2021

          Quanto ganha um Cientista de Dados?

          Quanto ganha um Cientista de Dados?

          Trending Tags

          • Python
            Fundamentos da Formação da Imagem

            Fundamentos da Formação da Imagem

            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

            aprenda python do zero - curso gratuito

            Projeto Python: um plano à prova de desculpas

            Entrevista com Rodrigo Gianotto, CTO do Grupo Primo

            Entrevista com Rodrigo Gianotto, CTO do Grupo Primo

            Projeto Python do Zero: evento 100% gratuito

            Projeto Python do Zero: evento 100% gratuito

            Aprenda Python e se destaque no mercado

            Aprenda Python e se destaque no mercado

            Python para análise de ações e investimentos

            Python para análise de ações e investimentos

            Como fazer gráficos rotulados em Python

            Como fazer gráficos rotulados em Python

            Trabalhando com Dados Desbalanceados

            Trabalhando com Dados Desbalanceados

            Trending Tags

            • Visão Computacional
              Fundamentos da Formação da Imagem

              Fundamentos da Formação da Imagem

              Como usar OpenCV e Python para calibrar câmeras

              Como usar OpenCV e Python para calibrar câmeras

              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

              Crie um sistema de vigilância com drones e Deep Learning

              Crie um sistema de vigilância com drones e Deep Learning

              Detector de Fadiga usando Python

              Detector de Fadiga usando Python

              Redes Neurais Convolucionais com Python

              Redes Neurais Convolucionais com Python

              Reduzindo o Overfitting com Data Augmentation

              Reduzindo o Overfitting com Data Augmentation

              Redes Neurais Multicamadas com Python e Keras

              Redes Neurais Multicamadas com Python e Keras

              Trending Tags

              • Sobre Mim
              No Result
              View All Result
              Sigmoidal
              No Result
              View All Result

              Deep Learning: Armazenamento de grandes quantidades de dados com HDF5

              Carlos Melo by Carlos Melo
              junho 7, 2022
              in Deep Learning, Python, Tutoriais
              0
              Home Artigos Deep Learning
              13
              SHARES
              433
              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
              Previous Post

              Redes Neurais Convolucionais com Python

              Next Post

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

              Carlos Melo

              Carlos Melo

              Carlos Melo fundou o Sigmoidal em 2019 e formou mais de 6 mil alunos com seus treinamentos nas área de tecnologia, Visão Computacional, Python e Data Science. É graduado em Ciências Aeronáuticas pela Academia da Força Aérea (AFA) e possui MBA em Gestão de Projetos e Processos pela Universidade da Força Aérea (UNIFA). Mestre em Ciências e Tecnologias Espaciais pelo Instituto Tecnológico de Aeronáutica (ITA), foi o primeiro brasileiro convidado a realizar o curso Space Operations da Royal Canadian Air Force no Canadá. Foi piloto da Força Aérea Brasileira por 16 anos, instrutor qualificado com mais de 3 mil horas de voo, Head da Divisão de Observação da Terra e cientista de dados no Centro de Operações Espaciais em Brasília.

              Related Posts

              Fundamentos da Formação da Imagem
              Visão Computacional

              Fundamentos da Formação da Imagem

              by Carlos Melo
              março 22, 2023
              Como usar OpenCV e Python para calibrar câmeras
              Artigos

              Como usar OpenCV e Python para calibrar câmeras

              by Carlos Melo
              março 17, 2023
              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

              by Carlos Melo
              dezembro 27, 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

              by Carlos Melo
              janeiro 7, 2023
              ChatGPT: A Inteligência Artificial que vai escrever seus códigos
              Artigos

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

              by Carlos Melo
              dezembro 20, 2022
              Next Post
              Data Science: Investigando o naufrágio do Titanic [Pt. 1]

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

              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

              Redes Neurais Multicamadas com Python e Keras

              Redes Neurais Multicamadas com Python e Keras

              junho 8, 2022
              Fundamentos da Formação da Imagem

              Fundamentos da Formação da Imagem

              março 22, 2023
              Aprenda Python e se destaque no mercado

              Aprenda Python e se destaque no mercado

              dezembro 14, 2022

              Navegar por Categoria

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

              Navegar por Tags

              cancer carreira cientista de dados cnn Cursos dados desbalanceados data science data science na prática decision tree deep learning gis gpt-3 gráficos healthcare iniciantes jupyter kaggle keras machine learning matplotlib medicina mnist nft nlp opencv pandas personal branding plotly portfólio profissão python random forest redes neurais redes neurais convolucionais regressão logística seaborn sklearn tensorflow titanic vagas visualização de dados visão computacional vídeo youtube árvore de decisão
              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
              • Matemática
              • NFT
              • Notícias
              • Projetos
              • Python
              • Teoria
              • Tutoriais
              • Visão Computacional
              • Youtube

              Navegar por Tags

              cancer carreira cientista de dados cnn Cursos dados desbalanceados data science data science na prática decision tree deep learning gis gpt-3 gráficos healthcare iniciantes jupyter kaggle keras machine learning matplotlib medicina mnist nft nlp opencv pandas personal branding plotly portfólio profissão python random forest redes neurais redes neurais convolucionais regressão logística seaborn sklearn tensorflow titanic vagas visualização de dados visão computacional vídeo youtube árvore de decisão

              Artigos Recentes

              • Fundamentos da Formação da Imagem
              • Como usar OpenCV e Python para calibrar câmeras
              • Como escrever uma Cover Letter poderosa para Data Science

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

              No Result
              View All Result
              • Home
              • Artigos
              • Tutoriais
              • YouTube
              • 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