Aprendizado de máquina e redes neurais - página 40

[MetaQuotes]

Rastreamento de veículos / monitoramento de tráfego yolov5+deepsort

Rastreamento de veículos / monitoramento de tráfego yolov5+deepsort

Para todos que vêm aqui do youtube ou apenas querem usar meu repositório para inferência. Este é um projeto muito antigo apenas para aprender CV quando eu estava na escola. Já faz muito tempo, então esqueci tudo o que fiz neste projeto de brinquedo. Eu editei deste repositório e adicionei algumas linhas de código para algumas restrições. Vocês podem usar esse repositório para referências. Obrigado.

As detecções geradas pelo YOLOv5 são passadas para o algoritmo Deep Sort , que rastreia os objetos.

Código: https://github.com/duongcongnha/Vehicle-tracking

[MetaQuotes]

Demonstração de rastreamento de veículos e estimativa de velocidade no 2º Workshop AI City Challenge da CVPR 2018

Demonstração de rastreamento de veículos e estimativa de velocidade no 2º Workshop AI City Challenge da CVPR 2018

Nossa equipe da Universidade de Washington é a vencedora da Faixa 1 (Análise de Fluxo de Tráfego) no 2º AI City Challenge Workshop CVPR 2018.

Os conjuntos de dados para o 2º AI City Challenge (2018) não estão mais disponíveis ao público. No entanto, você ainda pode acessar os conjuntos de dados do 3º AI City Challenge (2019) ou participar do último 4º AI City Challenge no CVPR 2020.

Eles forneceram um novo conjunto de dados em escala de cidade para rastreamento de veículos com várias câmeras, bem como reidentificação baseada em imagens. Eles também tinham um novo conjunto de dados para detecção de anomalias de tráfego. A escala dos conjuntos de dados e o número de veículos que estão sendo usados para avaliação são inéditos. O site do AI City Challenges está em https://www.aicitychallenge.org/ .

Código: https://github.com/zhengthomastang/2018AICity_TeamUW

[MetaQuotes]

Rastreamento de objetos com Opencv e Python

Código: https://pysource.com/2021/01/28/object-tracking-with-opencv-and-python/

Rastreamento de objetos com Opencv e Python

O tutorial em vídeo sobre rastreamento de objetos com OpenCV e Python explica a diferença entre detecção de objetos e rastreamento de objetos e mostra como criar um arquivo rastreador de objetos para rastreamento eficiente. O vídeo descreve os arquivos necessários necessários, como um vídeo e um arquivo rastreador de objeto, e mostra como codificar o arquivo main.py para exibição de vídeo em tempo real. O tutorial também aborda como remover pequenos elementos da máscara e definir uma região de interesse para extrair uma parte da imagem para focar nos veículos. O vídeo termina explicando o processo de rastreamento de objetos e adicionando IDs exclusivos aos objetos para contá-los corretamente. No entanto, o tutorial afirma que o método não é perfeito, mas serve como uma excelente introdução ao rastreamento de objetos, e um curso mais aprofundado sobre OpenCV e aprendizado profundo é recomendado.

• 00:00:00 Nesta seção, o palestrante apresenta a diferença entre detecção de objetos e rastreamento de objetos. O primeiro está detectando objetos quadro após quadro, enquanto o último está acompanhando os objetos ao longo dos quadros para rastrear sua história. O rastreamento de objetos é crucial em várias aplicações, como contagem de pessoas, rastreamento de trajetórias de objetos e contagem de carros passando em rodovias. O palestrante então apresenta os arquivos necessários para iniciar o projeto, incluindo um vídeo e um arquivo rastreador de objetos. Em seguida, o palestrante começa a codificar o arquivo main.py, começando com a importação da biblioteca OpenCV e criando um objeto de captura para ler os quadros do vídeo. Por fim, o palestrante mostra como exibir o vídeo em tempo real e criar um evento chave para fechar o vídeo.
  
  
• 00:05:00 Nesta seção, o palestrante discute o rastreamento de objetos usando OpenCV e Python. Eles explicam que, para esse método específico, é necessária uma câmera estável, o que significa que o fundo não muda com o tempo, enquanto apenas os objetos em movimento mudam. Ao usar um detector de objetos, os objetos em movimento podem ser extraídos da câmera estável. O detector cria uma máscara e o objetivo da máscara é tornar preto tudo o que não é necessário, enquanto os veículos que precisam ser detectados são brancos. As coordenadas dos elementos brancos são então extraídas e as que são muito pequenas são removidas. Em seguida, usando a função de encontrar contornos do OpenCV, os limites dos objetos brancos são encontrados e desenhados no quadro em verde.
  
  
• 00:10:00 Nesta seção, o tutorial em vídeo explica como remover pequenos elementos da máscara calculando a área do contorno e removendo qualquer contorno com área inferior a 100 pixels. Em seguida, o tutorial discute como definir uma Região de Interesse (ROI) para extrair uma parte da imagem para focar apenas os veículos naquele trecho específico da estrada, facilitando muito o processo de detecção. O tutorial descreve como definir o ROI especificando a posição, altura e largura da seção que contém os veículos que queremos rastrear. O tutorial termina explicando como aplicar a máscara ao ROI para realizar o rastreamento de objetos apenas naquela área específica.
  
  
• 00:15:00 Nesta seção do vídeo, o palestrante aplica o algoritmo de detecção de objetos ao ROI em vez de a todo o quadro e mostra como a detecção melhorou. No entanto, ainda há problemas com falsos positivos e o algoritmo de detecção. Para melhorar a detecção de objetos, o alto-falante ajusta o tamanho do histórico e o limiar var, que afeta a quantidade de falsos positivos. O alto-falante então extrai o retângulo ao redor de cada objeto detectado e o desenha na ROI em verde. Por fim, o alto-falante remove as sombras da imagem mantendo apenas os elementos brancos na imagem usando um operador de limite, resultando em uma detecção de objeto mais precisa.
  
  
• 00:20:00 Nesta seção, o vídeo explica o processo de rastreamento de objetos usando OpenCV e Python. É necessário importar o arquivo "tracker.py" e criar um objeto "tracker" para um rastreamento eficiente. O "rastreador" coleta caixas delimitadoras de objetos e os salva em uma matriz denominada "detecções". Cada caixa delimitadora tem seu conjunto distinto de valores de posição x, y, largura e altura. Essas caixas devem ter um valor mínimo de 100, para que o rastreador descarte os objetos irrelevantes. Uma série de objetos detectados é exibida quadro a quadro e a matriz de detecções é passada para o objeto rastreador. O rastreador retorna o histórico e os IDs exclusivos de cada objeto rastreado. A etapa inicial do rastreamento de objetos é a detecção do objeto, e isso só é possível se um objeto for detectado no quadro um.
  
  
• 00:25:00 Nesta seção, o vídeo discute a adição de IDs exclusivos ao recurso de rastreamento de objetos em OpenCV e Python. Cada objeto agora tem um ID diferente, evitando erros na contagem de objetos. Usando os IDs, os objetos podem ser contados corretamente e uma linha pode ser desenhada para detectar quando os objetos a cruzam. O vídeo termina explicando que o método mostrado é simples, não perfeito, mas uma boa introdução ao rastreamento de objetos. Para um conhecimento mais aprofundado sobre detecção e rastreamento de objetos, o criador recomenda a exibição de seu curso em vídeo sobre OpenCV e aprendizado profundo.

[MetaQuotes]

Roteiro de visão computacional | Como se tornar um engenheiro de visão computacional

Roteiro de visão computacional | Como se tornar um engenheiro de visão computacional

Este vídeo fornece um roteiro para se tornar um engenheiro de visão computacional, dividindo o processo de aprendizagem em quatro módulos: Python e OpenCV, robótica e programação de baixo nível, inteligência artificial e tópicos avançados. A importância de projetos práticos envolvendo dispositivos físicos, como robótica e Arduinos, é enfatizada, juntamente com a necessidade de ter um conhecimento básico de matemática. O palestrante também discute competições e projetos que podem ajudar aspirantes a engenheiros de visão computacional a aprimorar suas habilidades. Além disso, destaca-se a importância de soft skills como documentação e conhecimento de ferramentas de software como Git e Docker. Finalmente, recomenda-se obter diplomas em matemática, ciência de dados, ciência da computação ou engenharia, embora também seja possível aprender de forma independente por meio de projetos e cursos.

• 00:00:00 Nesta seção do vídeo, o palestrante apresenta um roteiro de visão computacional que abrange tudo o que uma pessoa precisa aprender para se tornar um desenvolvedor de visão computacional. O roteiro responde a três perguntas principais: quais habilidades são necessárias, em quais projetos você pode trabalhar para adquirir essas habilidades e quais diplomas universitários estão disponíveis para aprender essas habilidades. O roteiro é dividido em quatro modelos, com o primeiro modelo abrangendo Python e OpenCV, essenciais para resolver 70% dos problemas de visão computacional. O segundo modelo é sobre Robótica e programação de baixo nível, que inclui trabalhar com C++ e eletrônica. O terceiro e quarto modelos cobrem inteligência artificial e tópicos avançados, respectivamente. O palestrante sugere projetos iniciantes para cada modelo, como trabalhar em um robô seguidor de linha ou um leitor de código QR para construir conhecimentos e habilidades.
  
  
• 00:05:00 Nesta seção do vídeo, o palestrante discute a importância de trabalhar em projetos que envolvam dispositivos físicos como robótica e Arduinos. O palestrante explica que a programação desses dispositivos requer uma abordagem diferente, pois o mesmo código pode produzir resultados diferentes devido a fatores como ruído do sensor e mudanças de iluminação. O terceiro módulo mencionado pelo palestrante se concentra em inteligência artificial e aprendizado de máquina usando a popular biblioteca Python Scikit-learn, que pode ser usada para tarefas como classificação de imagens e detecção de objetos. Por fim, o palestrante também enfatiza a importância de se ter um conhecimento básico de matemática e como ela se relaciona com a visão computacional.
  
  
• 00:10:00 Nesta seção, o palestrante explica a importância de dividir o ambiente em diferentes regiões e como isso pode ser usado para detectar situações como cruzamentos de faixa, demonstrando uma imagem simples com diferentes regiões separadas por geometria básica. Ele enfatiza a necessidade de os engenheiros de visão computacional serem fluentes em matemática e recomenda o aprendizado básico em classificação de imagens e detecção de objetos, aprendizado secreto e geometria, antes de passar para habilidades mais avançadas em aprendizado de máquina, matemática e eletrônica. Ele sugere projetos como redes adversárias generativas e implementação de artigos de ponta em visão computacional para aprender aprendizado de máquina avançado, enquanto realiza projetos avançados de Arduino ou participa de competições de robótica para melhorar o conhecimento de eletrônica.
  
  
• 00:15:00 Nesta seção, o palestrante discute várias competições e projetos que podem ajudar aspirantes a engenheiros de visão computacional a aprimorar suas habilidades. Essas competições envolvem a construção de robôs e agentes que podem realizar tarefas complexas e competir com outras equipes. O palestrante enfatiza a importância de aprender os fundamentos da visão computacional, incluindo Python e OpenCV, que podem ajudar a resolver 70% dos problemas disponíveis. Os quatro módulos mencionados são: fundamentos, robótica, intenções artificiais e módulos avançados. Embora o módulo avançado seja importante, o palestrante sugere focar nos outros módulos primeiro, pois eles cobrem as habilidades essenciais necessárias para se tornar um engenheiro de visão computacional bem-sucedido.
  
  
• 00:20:00 Nesta seção, o palestrante discute as várias habilidades relacionadas a software que um desenvolvedor de visão computacional deve ter, além de ter conhecimento de visão computacional, aprendizado de máquina e Python. Essas habilidades incluem conhecer o básico de ferramentas como Git e Docker, bem como provedores de nuvem como AWS ou Google Cloud. Habilidades adicionais consideradas valiosas incluem desenvolvimento web ou móvel, conhecimento de JavaScript e saber como escrever documentação adequada, como um arquivo leia-me para um repositório GitHub ou documentar todo um processo. Embora nem todas essas habilidades sejam obrigatórias, elas podem ser benéficas para mostrar o trabalho de um desenvolvedor e resolver vários problemas.
  
  
• 00:25:00 Nesta seção, o palestrante enfatiza a importância da documentação para desenvolvedores de visão computacional, pois torna as coisas mais simples para todos. Eles também sugerem que todo desenvolvedor, não apenas desenvolvedores de visão computacional, deve dominar a documentação, pois é uma habilidade crucial. O palestrante destaca a importância de estar familiarizado com várias ferramentas de software e incentiva os aspirantes a engenheiros de visão computacional a aprender o máximo que puderem. Para os interessados em obter um diploma universitário, o palestrante recomenda graduações em matemática, ciência de dados, ciência da computação, engenharia elétrica ou qualquer graduação em engenharia, pois fornecem a base para abordar problemas e encontrar soluções. No entanto, o palestrante observa que é totalmente possível aprender tudo de forma independente, fazendo projetos e cursos.

[MetaQuotes]

CLASSIFICAÇÃO DE IMAGEM com conjunto de dados personalizado Yolov8 | Tutorial de visão computacional

Código: https://github.com/computervisioneng/image-classification-yolov8

CLASSIFICAÇÃO DE IMAGEM com conjunto de dados personalizado Yolov8 | Tutorial de visão computacional

Nesta seção, o apresentador explica como escolher o melhor modelo para o projeto e faz sugestões entre escolher o último modelo produzido no processo de treinamento ou selecionar o modelo com maior precisão. A decisão depende de vários fatores, incluindo dados, problema, caso de uso e processo de treinamento. O palestrante também explica como fazer todas as inferências e prever novas amostras importando YOLO e especificando o caminho absoluto para o modelo, usando uma imagem do computador local e mostrando os resultados. Os resultados fornecem muitas informações, incluindo as probabilidades e os nomes das categorias nas quais o classificador de imagem foi treinado.

• 00:00:00 Nesta seção, o YouTuber demonstra como construir um classificador de imagem usando YOLOv8 em um conjunto de dados personalizado. Ele começa mostrando o conjunto de dados, que inclui imagens de nuvens, chuva, sol e nascer do sol. Ele também explica a estrutura do arquivo que o YOLOv8 espera para entrada de dados. Felipe então passa a explicar três maneiras diferentes de treinar um classificador de imagem usando YOLOv8: a primeira é usando um script Python, a segunda é usando um Google Colab Notebook e a terceira é usando darknet, que é a estrutura subjacente para YOLOv8.
  
  
• 00:05:00 Nesta seção, o tutorial aborda as dependências necessárias para treinar um modelo de classificação de imagens usando Yolov8 e como instalá-las usando o interpretador Python no PyCharm. Os dois principais pacotes necessários são o Ultralytics e o NumPy, sendo o Ultralytics crucial na importação dos dados necessários para treinar o modelo. O tutorial examina o código necessário para treinar o modelo e requer a configuração do caminho absoluto para os dados no formato correto. Um teste também é feito por apenas uma época para garantir que tudo esteja funcionando corretamente antes de continuar com o treinamento adicional.
  
  
• 00:10:00 Nesta seção, o palestrante mostra onde estão localizados os resultados do processo de treinamento e explica a estrutura de pastas dentro da pasta de execuções. Ele então demonstra como treinar um classificador de imagem usando Yolov8 por meio da linha de comando usando um utilitário específico e os argumentos necessários. Ele passa a mostrar a simplicidade dessa abordagem treinando o modelo para apenas uma época e, em seguida, mostra onde os resultados são salvos em um novo diretório denominado "treinado 13". Por fim, o palestrante discute outra forma de treinar o modelo usando o Google Collab e fornece uma breve explicação do processo de configuração.
  
  
• 00:15:00 Nesta seção, o apresentador mostra um notebook que já foi criado para treinar modelos Yolov8 chamado "train.ipymb". Carregar conjuntos de dados no Google Drive é uma etapa essencial para os usuários acessarem seus dados do Google Collab, pois o processo exige que os usuários executem uma célula que conecta o Google Collab ao Google Drive. Saber o caminho para o conjunto de dados de um usuário no Google Drive é fundamental, pois os usuários precisam inserir esse caminho em seus notebooks para usar seus conjuntos de dados adequadamente. Por fim, o apresentador fornece comandos simples que os usuários podem executar para instalar as bibliotecas necessárias para treinar os modelos Yolov8.
  
  
• 00:20:00 Nesta seção do vídeo, o instrutor demonstra como treinar um classificador de imagem usando YOLOv8 e um conjunto de dados personalizado e como copiar os resultados obtidos em um ambiente do Google Colab para o Google Drive. Eles executam o processo de treinamento por uma época, copiam os resultados para o Google Drive e executam o processo de treinamento por 20 épocas. Por fim, mostram como analisar se o processo de treinamento resultou em um bom classificador de imagens. O instrutor enfatiza a importância de definir a variável do diretório de dados corretamente e sugere copiar os resultados para o Google Drive para simplificar o download e a análise.
  
  
• 00:25:00 Nesta seção, são analisados os resultados do processo de treinamento para um conjunto de dados personalizado usando YOLOv8. Os arquivos salvos no computador local são examinados, incluindo um arquivo de configuração listando todos os parâmetros EPA usados durante o processo de treinamento e um arquivo de resultados que inclui perda de treinamento e validação, bem como precisão. Um arquivo python que representa a perda e a precisão em diferentes épocas foi usado para determinar se a perda está diminuindo e se a precisão está aumentando durante o processo de treinamento. Conclui-se que uma abordagem simples, mas poderosa, é verificar se a perda de treinamento e a perda de validação estão diminuindo enquanto a precisão está aumentando.
  
  
• 00:30:00 Nesta seção, o palestrante explica como fica a precisão da avaliação quando aumentamos o número de épocas, mostrando que a precisão aumenta e depois estabiliza. Parâmetros diferentes e um treinamento mais personalizado podem ser usados para melhorar o processo para obter um modelo melhor. Também é explicado o diretório "weights", onde são salvos dois arquivos diferentes: "last.pt" e "best.pt". O ficheiro "last.pt" é o modelo produzido no final da última época de treino, enquanto o ficheiro "best.pt" é o modelo produzido no final da melhor época de treino. Na prática, o último modelo seria utilizado para obter os resultados finais.
  
  
• 00:35:00 Nesta seção, o palestrante discute como escolher o melhor modelo para o projeto e faz sugestões entre escolher o último modelo produzido no processo de treinamento ou selecionar o modelo com maior precisão. A decisão depende de vários fatores, incluindo dados, problema, caso de uso e processo de treinamento. O palestrante também explica como fazer todas as inferências e prever novas amostras importando YOLO e especificando o caminho absoluto para o modelo, usando uma imagem do computador local e mostrando os resultados. Os resultados fornecem muitas informações, incluindo as probabilidades e os nomes das categorias nas quais o classificador de imagem foi treinado.
  
  
• 00:40:00 Nesta seção do vídeo, o apresentador explica como usar um dicionário para identificar as classificações de uma imagem usando YOLOv8. Os resultados do classificador de imagem são inteiros correspondentes a diferentes categorias, e um dicionário é usado para identificar qual categoria cada inteiro representa. Além disso, obtém-se o vetor de probabilidade de todas as diferentes classes para uma determinada imagem e o apresentador demonstra como identificar a probabilidade máxima e sua categoria correspondente usando numpy. O apresentador conclui mostrando como classificar uma imagem usando o modelo YOLOv8 e sugere se inscrever em seu canal para mais projetos de engenharia de visão computacional.
  

[MetaQuotes]

Treine a detecção de objetos Yolov8 em um conjunto de dados personalizado | Guia passo a passo | Tutorial de visão computacional

Código: https://github.com/computervisioneng/train-yolov8-custom-dataset-step-by-step-guide

Treine a detecção de objetos Yolov8 em um conjunto de dados personalizado | Guia passo a passo | Tutorial de visão computacional

Este tutorial em vídeo fornece um guia passo a passo sobre como treinar um detector de objetos usando YOLOv8 em um conjunto de dados personalizado para aplicativos de visão computacional. O tutorial abrange aspectos importantes, como coleta de dados, anotação, formatação e treinamento, bem como a importância de analisar gráficos de função de perda e exemplos da vida real para avaliar o desempenho do modelo. O tutorial enfatiza o uso da ferramenta CVAT para anotação, aderindo ao formato de dados YOLOv8 necessário e criando um arquivo YAML de configuração. O tutorial também demonstra o uso do Google Colab e do PyCharm para treinar e testar o detector de objetos.

O vídeo demonstra o desempenho de um modelo de detecção de objetos YOLOv8 treinado em um conjunto de dados de alpaca. O palestrante usa um script Python para carregar vídeos e executar previsões, mostrando detecção quase perfeita em alguns casos e detecção estável em outros, com algumas detecções perdidas em um vídeo. O palestrante recomenda analisar as funções de perda de treinamento e validação e decidir se há espaço para melhorias antes de treinar o modelo novamente para obter um modelo mais poderoso e com melhor desempenho.

• 00:00:00 Nesta seção do vídeo, o apresentador explica a importância de coletar dados ao treinar um detector de objetos usando o YOLOv8, bem como as diferentes maneiras de coletar dados, como tirar suas próprias fotografias ou usar um conjunto de dados disponível publicamente como o conjunto de imagens abertas. O apresentador usa um conjunto de dados de alpaca para fins de demonstração, e os visualizadores veem exemplos das imagens contidas no conjunto de dados. Além disso, o apresentador menciona que eles podem fornecer aos visualizadores scripts para baixar e formatar os dados do conjunto de imagens abertas da maneira exata necessária para o tutorial.
  
  
• 00:05:00 Nesta seção do vídeo, o narrador discute o processo de anotação de dados usando a ferramenta CVAT, que é uma ferramenta de rotulagem que pode ser usada para detecção de objetos e tarefas de anotação relacionadas à visão computacional. O narrador demonstra como usar a ferramenta CVAT para anotar um conjunto de imagens para um conjunto de dados personalizado, explicando como criar um novo projeto e tarefa, carregar imagens e adicionar rótulos para os objetos a serem detectados. Embora o narrador já possua as anotações das imagens utilizadas, ele fornece um passo a passo para quem precisa anotar seus dados. O vídeo também destaca as vantagens e desvantagens de diferentes ferramentas de anotação, enfatizando os benefícios do uso do CVAT.
  
  
• 00:10:00 Nesta seção, o criador do vídeo mostra como rotular objetos em um conjunto de dados de imagem para detecção de objetos usando o algoritmo YOLOv8. O criador usa imagens de alpacas e demonstra como colocar o objeto em uma caixa de ligação, permitindo que o algoritmo detecte e identifique os objetos. Eles também explicam a importância de anotar seus próprios dados para se familiarizar com as diferentes situações que podem surgir durante a anotação e fornecer clareza sobre os objetos que estão sendo detectados. O criador observa que, embora a anotação de dados possa ser feita usando serviços externos, é fundamental anotar algumas das imagens você mesmo para uma melhor compreensão dos dados.
  
  
• 00:15:00 Nesta seção, é discutida a importância dos critérios para anotação de imagens, com o exemplo de um conjunto de dados de alpaca. As diferentes formas de definir caixas delimitadoras para objetos também são mostradas, incluindo ajustar a caixa firmemente ao objeto ou ter uma caixa delimitadora mais relaxada. A ferramenta de anotação cb80 é destacada como um aplicativo da Web útil e fácil de usar para formatar e anotar dados, enfatizando a importância da anotação de dados no treinamento de algoritmos de detecção de objetos.
  
  
• 00:20:00 Nesta seção do vídeo, o apresentador explica o formato de dados específico necessário para o YOLOv8 para treinar um detector de objetos. Todo algoritmo em aprendizado de máquina tem seus próprios requisitos de entrada de dados, e o YOLO precisa dos dados em um formato muito específico. O apresentador demonstra como exportar dados anotados do CV80 e convertê-los no formato YOLO. O formato YOLO requer que as anotações e imagens correspondentes tenham o mesmo nome e diferentes extensões de arquivo, com cada anotação da caixa delimitadora contendo um número de classe e quatro números flutuantes que definem a posição central, a largura e a altura da caixa delimitadora. Enfatiza-se que ter dados no formato correto é crucial para o treinamento de um detector de objetos.
  
  
• 00:25:00 Nesta seção, o palestrante explica como estruturar os dados para detecção de objeto de treinamento usando YOLOv8 em um conjunto de dados personalizado. O primeiro passo é criar dois diretórios: um para imagens e outro para rótulos, com nomes de diretórios específicos que não podem ser alterados. Dentro do diretório de imagens, todas as imagens que serão usadas para treinamento devem ser localizadas, e um diretório de trem pode ser usado por conveniência. Dentro do diretório labels, deve haver arquivos de anotação para cada imagem, seguindo um formato padrão onde cada linha especifica o ID da classe, a posição X/Y do centro da caixa delimitadora e a largura e altura da caixa delimitadora. O palestrante também explica como usar diretórios adicionais para dados de validação ou teste ou para diferentes versões dos dados.
  
  
• 00:30:00 Nesta seção, o tutorial em vídeo discute o processo de treinamento de seu detector de objetos com YOLO V8 usando Python ou o utilitário de linha de comando. O repositório oficial YOLO V8 oferece a opção de treinar com algumas instruções Python ou executando um comando no terminal. O tutorial passa por um guia passo a passo sobre como treinar um detector de objetos usando o YOLO V8 em um projeto PyCharm, incluindo a importação da biblioteca Ultralytics e a criação de um arquivo YAML de configuração. O tutorial também destaca que os usuários podem escolher entre trabalhar em um ambiente local ou no Google Colab.
  
  
• 00:35:00 Nesta seção do vídeo, o palestrante discute o arquivo de configuração para treinar um detector de objetos usando o YOLO V8 em um conjunto de dados personalizado. Eles explicam como definir os nomes das diferentes classes detectadas, o caminho absoluto para o diretório que contém as imagens e anotações e o caminho relativo para onde as imagens estão localizadas. O palestrante também menciona as duas palavras-chave, "train" e "val", que se referem aos dados de treinamento e validação, respectivamente. Eles enfatizam a importância de usar um caminho absoluto em vez de um caminho relativo para evitar problemas. O palestrante então demonstra como executar o arquivo e inicia o processo de treinamento por uma época, enfatizando a necessidade de aguardar até que o processo seja concluído. Finalmente, eles mostram os arquivos de saída gerados após a conclusão do processo de treinamento.
  
  
• 00:40:00 Nesta seção do tutorial em vídeo, o palestrante mostra os lotes de imagens usados para treinar o algoritmo de detecção de objetos YOLOv8, bem como imagens semelhantes para validação. O palestrante explica que estão realizando um treinamento raso e fictício, e mostra os arquivos utilizados para esse fim. O palestrante mostra como treinar o algoritmo a partir da linha de comando usando o terminal e também a partir de um bloco de anotações do Google collab. O notebook consiste em apenas cinco células, e o alto-falante demonstra como é simples fazer upload de dados, montar o Google Drive e treinar o algoritmo apenas especificando o caminho relativo ao local dos dados.
  
  
• 00:45:00 Nesta seção, o tutorial em vídeo mostra como usar o Google Colab para treinar um detector de objetos YOLOv8 em um conjunto de dados personalizado. O processo envolve salvar uma variável específica e executar o comando "pip install ultralytics" no ambiente do Google Colab por meio do comando ponto de exclamação. O tutorial mostra como inserir as mesmas linhas de código usadas no ambiente local e como especificar um caminho absoluto para o diretório do Google Drive. Uma vez carregados os arquivos e executados os comandos, o processo de treinamento é semelhante ao do ambiente local. O tutorial instrui os usuários a aguardar a conclusão da execução e lembrar de executar o comando que copia o diretório de resultados para o diretório escolhido no Google Colab.
  
  
• 00:50:00 Nesta seção, o tutorial em vídeo se concentra em testar o desempenho do detector de objetos Yolov8 que foi treinado em um conjunto de dados personalizado. O primeiro passo para testar o modelo envolve ir ao diretório onde todas as informações referentes ao processo de treinamento foram salvas. O vídeo mostra diferentes saídas e gráficos que podem ser usados para analisar o desempenho do modelo, incluindo matrizes de confusão, curvas de confiança F1 e gráficos de função de perda. O vídeo recomenda focar nos gráficos de perda, garantindo que todas as perdas estejam diminuindo, pois essa é uma maneira simples, mas poderosa, de analisar o desempenho do modelo. Diferentes situações nos gráficos de função de perda também são discutidas, como uma função de perda flatlining, que pode indicar que o modelo aprendeu tudo o que precisava aprender.
  
  
• 00:55:00 Nesta seção do vídeo, o apresentador discute a análise da função de perda para obter informações sobre o processo de treinamento de um modelo de detecção de objetos. Se a função de perda cair, tudo está indo bem, mas se subir, há um problema com o treinamento. Observar os gráficos e analisar essas informações é mais sobre pesquisa, mas o apresentador propõe uma maneira mais visual de avaliar o desempenho do modelo, que é olhar para exemplos reais e ver como o modelo se comporta em dados reais. O apresentador mostra exemplos do modelo que detecta alpacas da vida real em vídeos, que são dados completamente inéditos para testar o desempenho do modelo. Embora os resultados não sejam perfeitos, o desempenho é bom, e o apresentador argumenta que essa avaliação visual é mais relevante para um freelancer trabalhando no projeto de um cliente, pois o cliente pode não se importar com as plotagens e métricas, mas sim querer ver como o modelo executa em dados reais.

• 01:00:00 Nesta seção, o palestrante demonstra o desempenho do modelo de detecção de objetos YOLOv8 treinado em um conjunto de dados de alpaca em dados não vistos por meio de um script Python que carrega vídeos e executa previsões. As detecções parecem funcionar bem, com uma detecção quase perfeita em alguns casos e uma detecção estável em outros, exceto por algumas detecções perdidas em um vídeo. O palestrante aconselha analisar as funções de perda de treinamento e validação, verificando sua tendência de queda e a existência de espaço para melhorias para decidir se treina o modelo novamente, que é o que o palestrante faz para obter um modelo mais poderoso e com melhor desempenho.

[MetaQuotes]

Detecção de objetos Yolov8 + rastreamento de objetos de classificação profunda | Tutorial de visão computacional

Código: https://github.com/computervisioneng/object-tracking-yolov8-deep-sort

Detecção de objetos Yolov8 + rastreamento de objetos de classificação profunda | Tutorial de visão computacional

Este tutorial em vídeo demonstra como implementar um sistema de detecção e rastreamento de objetos usando YOLOv8 e deep sort. O apresentador percorre o processo passo a passo, desde a configuração do ambiente, carregamento e detecção de objetos em um vídeo usando o YOLOv8, até o rastreamento dos objetos detectados ao longo do tempo usando a classificação profunda. Eles também explicam a importância de criar a estrutura de arquivo correta e instalar as dependências necessárias. Depois que as detecções são extraídas do YOLOv8, o rastreamento de objetos Deep Sort é aplicado para acompanhar os objetos detectados ao longo do tempo. Por fim, o apresentador explica como salvar os quadros de saída final em um arquivo de vídeo e incentiva os espectadores a modificar o limite de detecção para obter melhor precisão.

• 00:00:00 Nesta seção do vídeo, o apresentador apresenta o projeto de trabalhar com detecção de objetos usando YOLOv8 e rastreamento de objetos usando deep sort. O objetivo é criar um algoritmo de rastreamento que possa acompanhar as pessoas que se movem em um vídeo e usar caixas delimitadoras de cores diferentes para indicar os objetos que estão sendo rastreados. O host mostra os repositórios YOLOv8 e deep sort que serão usados, bem como os dados de vídeo que serão testados. Por fim, o host apresenta um arquivo chamado "tracker.py", que é um wrapper em torno da classificação profunda que simplifica o processo de rastreamento de objetos usando funções de alto nível.
  
  
• 00:05:00 Nesta seção do vídeo, o apresentador explica como configurar o ambiente para o tutorial clonando o repositório necessário, baixando os arquivos necessários e importando as bibliotecas necessárias. Eles explicam a importância de criar a estrutura de arquivo correta e instalar as dependências corretas para garantir a compatibilidade com o código. O apresentador então demonstra como carregar um vídeo e ler quadros dele usando o OpenCV e como mostrar os quadros em uma janela.
  
  
• 00:10:00 Nesta seção, o apresentador demonstra como usar o modelo pré-treinado YOLOv8 para produzir detecções em um vídeo. Usando o Ultralytics, o modelo pré-treinado é importado e a função é chamada em um quadro do vídeo. Os resultados da detecção de saída são impressos, mas como os resultados estão em um tipo de objeto personalizado, eles precisam ser desempacotados e transformados em uma lista usando um loop for. As detecções de saída final são salvas em um novo objeto. Uma vez que o código é executado com sucesso, os resultados podem ser usados como dados de entrada para algoritmos de rastreamento de objetos.
  
  
• 00:15:00 Nesta seção do tutorial em vídeo, o palestrante demonstra como desempacotar todas as informações de detecção importantes do detector de objetos YOLOv8 e rastrear os objetos detectados usando o rastreamento de objetos Deep Sort. Eles mostram como extrair informações como o ID da classe, valor de confiança e coordenadas para cada detecção, a fim de transmiti-las ao algoritmo de rastreamento. O palestrante também mostra como inicializar e chamar o rastreador Deep Sort com as detecções e quadros para acompanhar os objetos detectados ao longo do tempo.
  
  
• 00:20:00 Nesta seção, o apresentador explica o processo de rastreamento de objetos de classificação profunda, que envolve recursos de computação na parte superior do quadro e os objetos detectados. O algoritmo corta o quadro e extrai recursos e, para percorrer todas as trilhas, o apresentador usa um loop para acessar a caixa delimitadora e o ID da trilha. Cada pessoa ou objeto detectado no vídeo tem um ID atribuído que permanece estável em todos os quadros. Para cada novo ID detectado, o apresentador o plota com uma cor diferente usando uma lista de cores aleatórias na visualização.
  
  
• 00:25:00 Nesta seção do vídeo, o palestrante resolve o problema de salvar o vídeo com todos os diferentes quadros e detecções de volta ao computador local. Um novo objeto, gravador de vídeo CV2, é criado para salvar o vídeo com um nome e local especificados. O vídeo é salvo usando um codec MP4 e a mesma taxa de quadros do vídeo original. O palestrante enfatiza que tudo está funcionando corretamente, embora a detecção em tempo real não seja alcançada devido aos muitos objetos sendo carregados e a execução sendo executada em uma CPU. No geral, o problema de detecção de objetos usando YOLOv8 e rastreamento de objetos usando Deep SORT foi resolvido com sucesso.
  
  
• 00:30:00 Nesta seção, o palestrante conclui o tutorial revisando as etapas finais necessárias para implementar um sistema bem-sucedido de detecção e rastreamento de objetos usando YOLOv8 e deep sort. Eles demonstram como salvar os quadros de saída em um arquivo out.mp4 e mostram sua conclusão bem-sucedida. Além disso, o palestrante menciona os possíveis erros de detecção e incentiva os espectadores a modificar o limite de detecção para melhorar a precisão do sistema para detectar objetos como pássaros. No geral, este tutorial serve como um guia útil para quem deseja implementar um sistema de detecção e rastreamento de objetos usando técnicas de visão computacional.

[MetaQuotes]

Segmentação de imagem com conjunto de dados personalizado Yolov8 | Tutorial de visão computacional

Código: https://github.com/computervisioneng/image-segmentation-yolov8

Dados: https://drive.google.com/drive/folders/1JvA2IvHBy2QOnAtPtoy4JbEEmtbz5dnK

Segmentação de imagem com conjunto de dados personalizado Yolov8 | Tutorial de visão computacional

Este tutorial aborda o processo de anotar imagens e criar uma máscara binária para segmentação semântica, formatar e estruturar o conjunto de dados para treinamento com YoloV8, treinar o modelo no Google Collab, analisar os resultados do treinamento e fazer previsões usando um script Python. O apresentador enfatiza a importância de estruturar o sistema de arquivos e analisar a função de perda e as métricas de validação para treinar um bom modelo para o conjunto de dados personalizado YoloV8. Eles também discutem o impacto de dados falhos na qualidade da previsão e recomendam usar as previsões do modelo atual para treinar um modelo novo e aprimorado. No geral, o tutorial fornece um guia abrangente para segmentação de imagem com o conjunto de dados personalizado YoloV8.

• 00:00:00 Nesta seção do vídeo, o instrutor mostra o conjunto de dados que será usado para segmentação semântica: um conjunto de imagens de pato com as máscaras binárias correspondentes. A máscara binária tem todos os pixels brancos para um objeto na imagem e todos os pixels pretos para todo o resto. O instrutor baixa esse conjunto de dados da versão 7 do ativo de imagens abertas e mostra o site cvat.ai caso seja necessário anotar seus próprios dados de imagem. Em seguida, o instrutor mostra como usar essa ferramenta para criar uma máscara binária para uma imagem em apenas uma anotação de imagem.
  
  
• 00:05:00 Nesta seção do tutorial, o apresentador demonstra como anotar uma imagem e criar uma máscara binária para segmentação semântica. Usando a imagem de um pato como exemplo, eles orientam o espectador através do processo de desenho de um polígono para criar a máscara ao redor do corpo do pato, incluindo uma discussão sobre a possibilidade de anotar certas partes sob a água como parte do pato ou não. O apresentador enfatiza que a máscara não precisa ser perfeita em pixels, mas precisa ser precisa o suficiente para criar uma boa máscara. Finalmente, eles mostram como salvar e baixar os dados anotados para uso na criação de um conjunto de dados.
  
  
• 00:10:00 Nesta seção, o palestrante explica como formatar e estruturar o conjunto de dados para treinar um modelo de segmentação semântica com YoloV8. A primeira etapa é baixar os dados necessários usando a opção Export Task Data Set e selecionando a máscara de segmentação. Após o download dos dados, eles precisam ser organizados em uma estrutura de diretórios contendo as imagens, máscaras e rótulos. As máscaras geradas a partir das imagens precisam ser convertidas em um formato de arquivo diferente por meio de um script Python fornecido pelo palestrante. Este formato de arquivo é exigido pelo YoloV8 e contém as mesmas informações que as máscaras binárias. O palestrante também destaca a importância de estruturar o sistema de arquivos de uma maneira particular para que o YoloV8 possa encontrar e usar os dados.
  
  
• 00:15:00 Nesta seção, o apresentador explica a estrutura de diretório necessária para a segmentação de imagens com o conjunto de dados personalizado Yolov8. Os usuários precisam ter dois diretórios: um chamado "train", que contém todos os dados de treinamento para o modelo de segmentação semântica, e o outro chamado "ball", contendo as imagens que serão utilizadas para validar o modelo. Dentro desses diretórios existem dois outros diretórios -- "images" e "labels" -- que possuem dois subdiretórios chamados "train" e "ball". O primeiro contém todas as anotações geradas a partir das máscaras de treinamento. O apresentador configura a estrutura no pycharm e passa a explicar como treinar o modelo usando um modelo Yolov8 pré-treinado pela Ultralytics, incluindo a implementação do código e a edição do arquivo de configuração.
  
  
• 00:20:00 Nesta seção, o palestrante explica que o modelo de segmentação semântica é treinado no Google Collab devido ao acesso a uma GPU gratuita, tornando o processo muito mais rápido. O palestrante recomenda o upload de dados, incluindo diretórios e imagens, e o arquivo config.yaml antes de iniciar o processo. Além disso, o palestrante mostra e explica como executar cada célula no Notebook Júpiter e compartilha a localização de seus dados no Google Drive, incentivando o usuário a fazer o mesmo ao enviar seus dados. Por fim, o palestrante menciona a instalação do Ultralytics para que possam usar o YOLOv8 no Notebook e enfatiza a garantia do uso do Google Collab com GPU enquanto verifica o tipo de tempo de execução.
  
  
• 00:25:00 Nesta seção do tutorial, o palestrante treina o modelo por 10 épocas e salva os resultados na pasta segment train 2. O próximo passo é analisar os resultados do treinamento para validar se tudo está funcionando bem. A maneira mais fácil de fazer isso é copiando todo o conteúdo do diretório onde os resultados são salvos no Google Drive. Depois que os resultados são baixados em um computador local, o palestrante recomenda focar na análise da função de perda, perda de segmentação, perda de treinamento e gráficos de perda de validação para garantir que a função de perda esteja diminuindo. Este é um bom sinal de que as coisas estão funcionando bem, enquanto uma função de perda crescente indica um problema sério.
  
  
• 00:30:00 Nesta seção, o palestrante fala sobre a análise da função de perda e métricas de validação para treinar um bom modelo para o conjunto de dados personalizado Yolov8. É um bom sinal se a perda de treinamento e validação estiver diminuindo, indicando uma tendência de melhorar a qualidade da previsão. No entanto, o palestrante adverte que anotações ausentes e outras falhas nos dados de treinamento podem afetar a qualidade da previsão, levando a tendências inesperadas no gráfico da função de perda. Portanto, o palestrante aconselha a não enlouquecer analisando esses gráficos e incluir uma análise das previsões para avaliar o desempenho geral do modelo.
  
  
• 00:35:00 Nesta seção, o palestrante discute a importância de analisar os resultados da validação e avaliação de um modelo treinado em um conjunto de dados, que não é perfeito e contém erros. Esses erros podem ser resolvidos usando as previsões do modelo atual para treinar um modelo novo e aprimorado. O palestrante mostra o diretório onde estão salvos os pesos do modelo, explicando que last.pt e best.pt representam o último e o melhor desempenho dos modelos durante o treinamento, respectivamente. Por fim, o orador recomenda a utilização do less.pt por considerar muito mais informação do que o modelo best.pt.
  
  
• 00:40:00 Nesta seção do tutorial em vídeo sobre segmentação de imagem com conjunto de dados personalizado YOLOv8, o apresentador demonstra como fazer previsões usando um script Python. Ele começa importando o pacote YOLO do Ultralytics e define o modelo usando less.pt do diretório de resultados. Ele então especifica o caminho da imagem e importa o CV2 para abrir e ler esta imagem. O apresentador obtém os resultados do modelo chamando o modelo na imagem e repete os resultados para obter a máscara prevista. Ele redimensiona a máscara para o tamanho da imagem original e a salva como output.png. O apresentador também mostra como sobrepor a máscara na imagem original para garantir uma boa previsão.
  
  
• 00:45:00 Nesta seção, o apresentador demonstra o resultado do modelo de segmentação semântica que treinou com o YOLOv8. Usando uma imagem sobreposta e transparência, eles mostram que, embora a máscara não seja 100% perfeita, é um resultado muito bom considerando os erros nos dados. O apresentador então resume todo o processo, desde anotar os dados, treinar o modelo, validá-lo e fazer previsões. Por fim, eles incentivam os espectadores a se inscrever em seu canal e conferir outros vídeos que publicaram.

[MetaQuotes]

Detecção de objetos do Tensorflow em 5 horas com Python | Curso Completo com 3 Projetos

Obtenha o código Tensorflow Object Detection Python Course Code: https://github.com/nicknochnack/TFODCourse

Tensorflow Object Detection React App: https://github.com/nicknochnack/TFODApp

Tensorflow Object Detection para Raspberry Pi: https://github.com/nicknochnack/TFODRPi

Detecção de objetos do Tensorflow em 5 horas com Python | Curso Completo com 3 Projetos

Parte 1

• 00:00:00 Nesta seção, o instrutor apresenta o curso de detecção de objetos que se destina a levar iniciantes completos em detecção de objetos a um nível proficiente como praticantes. O curso é abrangente e abrange a instalação e configuração da API de detecção de objetos do TensorFlow, coleta e rotulagem de imagens, treinamento do modelo, exportação do modelo de detecção para diferentes formatos e teste dos modelos em vários casos de uso. O curso é todo feito usando ferramentas de código aberto, principalmente detecção de objetos Python e TensorFlow, facilitando o reaproveitamento do código para detectar vários objetos. O instrutor também explica os benefícios de usar a API de detecção de objetos do TensorFlow, que acelera o processo de criação de modelos de detecção de objetos devido aos vários recursos adicionais que oferece.
  
  
• 00:05:00 Nesta seção, o instrutor explica a diferença entre programação tradicional e aprendizado de máquina, onde, em vez de definir regras explícitas para detectar objetos, o aprendizado de máquina usa dados e respostas para treinar um modelo de detecção de objetos para aprender as regras. O modelo pode detectar objetos em imagens estáticas e feeds de vídeo em tempo real e pode ser exportado e convertido em diferentes formatos como tensorflow.js e tf lite usando congelamento e conversão. O ajuste de desempenho é crucial para melhorar a precisão do modelo, e o instrutor aborda esse tópico na etapa seis. Por fim, o instrutor demonstra três projetos, incluindo o uso de um microscópio USB para detectar defeitos em peças pequenas, a detecção de objetos em um videogame e a contagem do número de objetos que passam por uma webcam.
  
  
• 00:10:00 Nesta seção, o instrutor apresenta os três projetos que serão abordados no tutorial, que envolvem o treinamento de um modelo de detecção de objetos para identificar defeitos em placas de circuito impresso, detecção de gestos manuais e integração do modelo em um aplicativo da web, e realizando detecção de objetos em tempo real usando um Raspberry Pi. O instrutor fornece três conjuntos de códigos no Github para cada um dos projetos, que serão usados para construir os modelos passo a passo. O primeiro passo é clonar o código e criar um ambiente virtual, que é explicado como sendo um cômodo separado de uma casa. Esta seção também inclui dicas úteis para seguir o tutorial, como revisar cada etapa antes de prosseguir, fazer anotações e pedir ajuda, se necessário, por meio do servidor Discord fornecido.
  
  
• 00:15:00 Nesta seção do vídeo, o instrutor explica a importância de usar um ambiente virtual ao trabalhar com modelos de detecção de objetos do TensorFlow. Ele o descreve como criar uma nova sala em uma casa onde todas as dependências de detecção de objetos são instaladas para garantir que não entrem em conflito com as bibliotecas instaladas anteriormente. O instrutor então fala sobre as dependências necessárias para trabalhar com o TensorFlow, incluindo Visual C++ Build Tools e CUDA e CUDNN para aceleração baseada em GPU. Ele explica que essas bibliotecas são essenciais para um treinamento mais rápido dos modelos de detecção de objetos e mostra como baixá-las e instalá-las. No geral, esta seção fornece uma base essencial necessária para configurar um ambiente de desenvolvimento para criar modelos de detecção de objetos do TensorFlow.
  
  
• 00:20:00 Nesta seção do tutorial em vídeo, o instrutor discute os requisitos necessários para instalar o TensorFlow Object Detection, incluindo as versões específicas do Python, compilador GCC, Bazel, CUDA e cuDNN que são necessários. O instrutor enfatiza que combinar as versões do TensorFlow, CUDA e cuDNN é essencial para utilizar GPUs durante o treinamento. Eles fornecem links para guias de instalação para Windows e Linux/macOS e aconselham os visualizadores a verificar sua versão do TensorFlow e obter as versões CUDA e cuDNN apropriadas. Além disso, o instrutor menciona que criou um guia de erros para problemas comuns que ocorrem durante a instalação ou durante a execução do notebook de detecção de objetos. O guia inclui soluções para diferentes erros e pode ser encontrado no link do repositório GitHub fornecido.
  
  
• 00:25:00 Nesta seção, o instrutor mostra como configurar um ambiente virtual para detecção de objetos do TensorFlow usando Python. Ele indica os passos a seguir para criar o ambiente, que envolve a clonagem de um repositório com o código e as dependências necessárias, a criação de um ambiente virtual usando o pacote venv do Python e a ativação do ambiente. Criar um ambiente virtual é semelhante a criar um novo cômodo em uma casa, onde é possível isolar bibliotecas e dependências para trabalhar em projetos de detecção de objetos do TensorFlow em um ambiente isolado.
  
  
• 00:30:00 Nesta seção, o criador do vídeo discute o processo de criação de um ambiente virtual para TensorFlow Object Detection (TFOD) para manter o treinamento, o aplicativo e o código Raspberry Pi separados. O criador do vídeo segue as etapas para ativar o ambiente virtual, incluindo a execução de um comando em uma máquina Windows para ativar o ambiente. Há uma demonstração de como atualizar o instalador do pip e, em seguida, instalar o TensorFlow. O benefício dessas atualizações é a capacidade de ver as instalações em tempo real dentro da pasta de pacotes do site. Observe que, às vezes, a instalação do TensorFlow requer várias tentativas, e o criador do vídeo possui um script de verificação para garantir que tudo esteja instalado corretamente.
  
  
• 00:35:00 Nesta seção, o palestrante explica como instalar os pacotes necessários e configurar um ambiente virtual com Jupyter Notebook usando iPy Kernel. Eles também fornecem instruções para instalar Anaconda Python e Jupyter Notebooks para aqueles que são novos. Em seguida, eles explicam como instalar o iPy Kernel e associá-lo ao Jupyter Notebook para permitir uma carga de trabalho de ciência de dados mais eficiente. Por fim, o palestrante mostra como validar o ambiente virtual e começar a coletar e rotular imagens como parte da próxima etapa para a construção de um modelo de detecção de objetos do TensorFlow.
  
  
• 00:40:00 Nesta seção, o instrutor enfatiza a importância de coletar e rotular boas imagens ao treinar modelos de detecção de objetos. Para demonstrar isso, ele usa um notebook Jupyter para coletar imagens de uma webcam e a biblioteca LabelImg para rotular as imagens. O instrutor compartilha as melhores práticas a serem lembradas ao rotular, como manter as etiquetas o mais apertadas possível e incluir fotos de objetos em diferentes ângulos e sob diferentes condições de iluminação. Outra prática recomendada importante é começar com 10 a 20 fotos de cada aula, mas o instrutor começa com menos e mostra como adicionar fotos adicionais para retreinar o modelo se o desempenho estiver abaixo do ideal. Finalmente, o instrutor explica que fornecer ao modelo uma variedade de imagens sem uma tela verde atrás do objeto o tornará mais generalizado e mais capaz de detectar objetos.
  
  
• 00:45:00 Nesta seção, o instrutor orienta os visualizadores pelo componente de coleta de imagens do tutorial de detecção de objetos do TensorFlow. O tutorial começa instalando o OpenCV, uma popular biblioteca de visão computacional usada para acessar a webcam e coletar imagens. O instrutor enfatiza a importância de garantir que as dependências estejam instaladas no ambiente virtual para manter o controle e garantir o bom funcionamento. O código importa as dependências necessárias, incluindo UUID, SO e hora, que serão usadas para garantir a conformidade com diferentes caminhos de arquivo e capturar imagens em diferentes ângulos. O tutorial define os diferentes rótulos a serem coletados e explica que os rótulos podem ser alterados com base nos objetos desejados a serem detectados. Os rótulos são armazenados em uma lista, e o instrutor explica que o número de imagens coletadas para cada rótulo é definido pela variável "número de imagens".
  
  
• 00:50:00 Nesta seção, o instrutor discute a configuração da estrutura de pastas para detecção de objetos, a importância de ter um bom número de imagens ao começar e como capturar imagens usando uma webcam ou outro dispositivo de captura. A estrutura de pastas é criada usando um caminho de arquivo específico que deve ser seguido ao longo do tutorial. O código percorre todos os rótulos, conecta-se à webcam e captura imagens para cada rótulo. O instrutor enfatiza a importância de especificar corretamente o número do dispositivo de captura de vídeo para a webcam, pois podem ocorrer erros se estiver incorreto.
  
  
• 00:55:00 Nesta seção, o instrutor explica o código para coletar imagens para detecção de objetos. O código percorre os rótulos e captura os quadros usando a webcam. Ele cria uma nova imagem e a coloca dentro da respectiva pasta de etiquetas com um nome de identificador exclusivo. O comando cv2.iamwrite é usado para gravar a imagem em um arquivo e mostrá-lo na tela. O código também permite que o usuário pressione a tecla q para escapar a qualquer momento e fecha tudo quando terminar. O instrutor enfatiza que é fundamental capturar imagens em diferentes posições para a construção de um modelo generalizado.

Parte 2

• 01:00:00 Nesta seção, o palestrante enfatiza a importância da prototipagem o mais rápido possível para projetos científicos para estabelecer a viabilidade e possibilidade do projeto. Para ilustrar, o palestrante dá um exemplo de detecção de LEDs tortos, o que exigiria um modelo hiperpreciso ou um sensor como um microscópio. A prototipagem rápida com um modelo de rede móvel e uma webcam pode apresentar desempenho ruim, o que indica a necessidade de uma técnica ou sensor diferente. A prototipagem ajuda a estabelecer rapidamente uma linha de base para melhoria, e o palestrante passa a treinar o modelo com as imagens coletadas para detecção de aprovação, enfatizando a importância de excluir imagens de baixa qualidade e capturar mais imagens de boa qualidade para melhor detecção.
  
  
• 01:05:00 Nesta seção, o instrutor apresenta o pacote Label Image que será usado para rotular as imagens. Os usuários podem acessar o repositório do Github para verificar o pacote. Depois disso, o instrutor mostra como instalar as dependências necessárias, pi qt5 e lxml, e criar uma nova pasta chamada tensorflow e label image para salvar o pacote. Em seguida, o instrutor demonstra como clonar o repositório do Github e instalar o pacote de imagens de etiquetas executando comandos específicos. Por fim, o instrutor abre o aplicativo de etiqueta de imagem e se prepara para rotular as imagens.
  
  
• 01:10:00 Nesta seção, o instrutor demonstra o processo de rotulagem de imagens para detecção de objetos usando o software OpenCV Labeling. O processo inclui abrir o diretório específico no software e selecionar as imagens a serem rotuladas. O instrutor aconselha ser o mais preciso possível com os rótulos de detecção e garantir que os nomes dos rótulos correspondam aos das anotações e da etapa de treinamento. Além disso, o instrutor incentiva os espectadores a pensar em diferentes aplicações de detecção de objetos e experimentá-los usando o mesmo processo de definição de rótulos, coleta de imagens e rotulagem. A importância de garantir que as anotações correspondentes existam para cada imagem também é enfatizada.
  
  
• 01:15:00 Nesta seção, o instrutor explica como rotular uma imagem criando um arquivo de anotação. O arquivo de anotação é um arquivo xml que descreve a localização do objeto na imagem. O instrutor mostra como rotular uma imagem com vários objetos e explica como salvar as anotações corretamente. O processo de rotulagem de imagens pode ser ampliado pela terceirização ou pelo uso de ferramentas mais recentes que automatizam o processo de rotulagem usando modelos leves de detecção de objetos.
  
  
• 01:20:00 Nesta seção, o instrutor de vídeo mostra como rotular imagens usando imagem de rótulo e como prototipar para garantir que você está usando a técnica correta antes de criar um modelo de detecção de objetos enormes com milhares de imagens. Ele recomenda começar com a rotulagem de 10 a 25 imagens para mantê-lo super rápido e usar os sensores certos para obter os níveis certos de dados. O instrutor também explica a importância de dividir as imagens em uma partição de treinamento e teste para treinar o modelo em um segmento de imagens e testá-lo em um conjunto de imagens nunca visto antes. Ele cria duas novas pastas chamadas train e test dentro da pasta images para armazenar as imagens e anotações de treinamento e teste.
  
  
• 01:25:00 Nesta seção, aprendemos como preparar os dados de imagem que coletamos e rotulamos para treinar nosso modelo de detecção de objetos. Criamos duas pastas, training e testing, para armazenar nossas imagens e anotações, certificando-se de pegar os arquivos de imagem e anotação para cada aula. Em seguida, explicamos como convertê-los em registros do TensorFlow para serem usados no treinamento. Também abordamos algumas práticas recomendadas para nomear e organizar nossos dados. Por fim, apresentamos as dependências necessárias para treinar um modelo de detecção de objetos do TensorFlow e como avaliar nosso modelo usando métricas de avaliação.
  
  
• 01:30:00 Nesta seção, o palestrante discute as métricas de avaliação que você obtém após treinar seu modelo de detecção de objetos. Essas métricas incluem precisão e precisão média média (MAP), que calcula a proporção de detecções corretas. Eles são calculados com base no número de verdadeiros positivos, falsos positivos, verdadeiros negativos e falsos negativos. O palestrante explica que precisão e recall são muito importantes na hora de avaliar o desempenho do modelo. Além disso, o palestrante menciona que a escolha do zoológico do modelo TensorFlow afeta a precisão e a velocidade do modelo. Diferentes modelos têm diferentes arquiteturas que resultam em diferentes níveis de precisão e velocidade, e os profissionais precisam escolher o modelo apropriado para seu caso de uso.
  
  
• 01:35:00 Nesta seção, a transcrição discute as compensações entre velocidade e precisão do modelo ao escolher uma arquitetura de modelo para TensorFlow Object Detection. O vídeo apresenta diferentes opções de modelos e suas correspondentes velocidades de quadros e pontuações médias de precisão. O apresentador observa que certas arquiteturas podem ser rápidas e altamente precisas, enquanto outras podem ser mais lentas, mas mais precisas. Os benefícios de usar a API do modelo TensorFlow Update Detection também são mencionados, como o uso de técnicas de pré-processamento e pós-processamento e aumento de imagem. A seção termina com uma discussão sobre como treinar um modelo usando uma instância de nuvem, se desejado.
  
  
• 01:40:00 Nesta seção, o instrutor explica a configuração do modelo TensorFlow Object Detection, que envolve a configuração do nome e URL do modelo pré-treinado, bem como variáveis como o script de geração de registro tf e o nome do mapa de rótulo. A estrutura de pastas para o modelo também é mostrada, com a área de trabalho contendo pastas para anotações, imagens, modelos e pontos de verificação. A próxima etapa é baixar os modelos TensorFlow do zoológico de modelos TensorFlow e instalar o pacote TensorFlow Object Detection, que o instrutor percorre passo a passo para garantir uma instalação bem-sucedida. O processo envolve a clonagem do repositório TensorFlow Object Detection e a instalação das dependências necessárias.
  
  
• 01:45:00 Nesta seção, o apresentador explica como clonar e instalar a API do modelo TensorFlow Object Detection. A API do modelo pode ser baixada no jardim de modelos do TensorFlow, que possui muita documentação e tutoriais de código aberto. O apresentador demonstra como navegar até a pasta de pesquisa, que contém todos os arquivos necessários para usar a API TensorFlow Object Detection Model. Depois de clonar a pasta de pesquisa, o apresentador explica como instalar o protoc e outros componentes necessários para instalar com sucesso a API do modelo TensorFlow Object Detection. Por fim, o apresentador mostra como verificar a instalação executando um script de verificação para verificar se a API TensorFlow Object Detection foi instalada com sucesso.
  
  
• 01:50:00 Nesta seção, o instrutor passa pelo processo de verificação e instalação do Tensorflow para detecção de objetos. Ele explica que um script de verificação é usado para garantir que o Tensorflow seja instalado corretamente e que possa ser executado para verificar se há erros. O script é um script de detecção de objeto Tensorflow padrão que indica se o Tensorflow está ou não instalado quando executado. Se o Tensorflow não estiver instalado corretamente, o instrutor fornecerá orientações sobre como configurá-lo, incluindo a instalação de pacotes adicionais, como matplotlib e yaml. O instrutor garante ao espectador que, se encontrar erros, poderá pesquisá-los no Google, pois são comumente encontrados e fáceis de resolver. Finalmente, ele afirma que alcançar com sucesso o sinal "ok" na parte inferior do script de verificação significa que o Tensorflow foi instalado corretamente.
  
  
• 01:55:00 Nesta seção, o vídeo aborda o processo de instalação do TensorFlow e os pacotes necessários para detecção de objetos. O instrutor mostra como instalar TensorFlow, Matplotlib, Protobuf, Pillow e Pymel. O instrutor recomenda verificar o processo de instalação, pois pode ser diferente dependendo do seu ambiente. O vídeo também mostra as etapas para instalar o CUDA e o CuDNN, necessários se você quiser usar a GPU para treinamento. O instrutor explica como encontrar a versão correta de CUDA e CuDNN e passa pelo processo de instalação. Por fim, o instrutor demonstra como importar a API de detecção de objetos com êxito para o notebook reiniciando o kernel.

Parte 3

• 02:00:00 Nesta seção, o instrutor passa pelo processo de download e instalação do Nvidia cuDNN, que é necessário se você estiver treinando em uma GPU. Primeiro, você precisa se inscrever para uma conta gratuita de desenvolvedor da Nvidia, selecionar baixar cuDNN e fazer login. Existem duas versões disponíveis e você precisa baixar a versão compatível com sua versão do TensorFlow. O instrutor explica como extrair o arquivo compactado e copiar os arquivos cuDNN em suas respectivas pastas dentro do local de instalação do CUDA. Depois de copiar os arquivos, a última etapa é garantir que a pasta CUDA seja adicionada ao seu caminho em uma máquina Windows.
  
  
• 02:05:00 Nesta seção do vídeo, o instrutor explica o processo de instalação do TensorFlow e como testar se ele está funcionando corretamente ou não. O vídeo segue para o processo de download de um modelo de detecção de objeto pré-treinado do zoológico de modelos do TensorFlow, que será usado para aprendizado de transferência para detectar objetos personalizados. O instrutor demonstra como baixar o modelo e explica os diferentes componentes dos arquivos baixados. Por fim, um mapa de rótulos é criado para representar os diferentes rótulos para a detecção de objetos personalizados.
  
  
• 02:10:00 Nesta seção, o instrutor explica a criação de um mapa de etiquetas e geração de registros tf. Ele ressalta a importância da rotulagem adequada, pois o arquivo de mapa de etiquetas será usado posteriormente durante todo o processo de treinamento. O vídeo orienta como gerar um trem e um registro de teste e como atualizar os componentes do caminho para o modelo, especificamente o ponto de verificação de ajuste fino, o caminho do mapa de rótulo e o caminho de entrada. Por fim, destaca a relevância do arquivo de configuração do pipeline, que determina a arquitetura do modelo e deve ser customizado para modelos específicos.
  
  
• 02:15:00 Nesta seção do vídeo, o instrutor explica como configurar o arquivo de configuração para treinar o modelo. O arquivo de pipeline é copiado da pasta de modelos pré-treinados e, em seguida, a configuração é feita por meio de código, configurando todos os diferentes caminhos de arquivo junto com o número de classes e configurando ponto de verificação de ajuste fino, caminho de mapa de rótulo, caminho de entrada etc. Depois que a configuração é concluída, o modelo pode ser treinado executando o script de treinamento do modelo com os argumentos necessários, como caminho do arquivo pipeline.config, configuração do pipeline e o número de etapas de treinamento. Sugere-se executar o comando em um prompt de comando separado fora do notebook para ver o progresso do treinamento do modelo.
  
  
• 02:20:00 Nesta seção, o instrutor soluciona erros que ocorrem durante o processo de treinamento de detecção de objetos. Ele explica que a maioria dos erros é resolvida instalando a biblioteca certa ou procurando soluções online. Ele também observa que os usuários devem garantir que instalaram a versão correta da GPU do TensorFlow se quiserem aproveitar a GPU. O instrutor orienta os visualizadores pelo processo de desinstalação e reinstalação de bibliotecas para resolver erros específicos, enfatizando que esse processo pode levar algum tempo, mas é necessário para uma execução bem-sucedida do treinamento de detecção de objetos. Por fim, ele mostra aos espectadores como verificar se instalaram as bibliotecas corretas e como monitorar o andamento da execução do treinamento.
  
  
• 02:25:00 Nesta seção, o instrutor discute o processo de treinamento do modelo e avaliação de suas métricas de desempenho. Depois que o treinamento é iniciado, as métricas de perda aparecem a cada 100 etapas, indicando que o modelo está sendo treinado corretamente. A saída do modelo de treinamento para 2.000 passos é gerada, indicando que o modelo foi treinado com sucesso com uma perda final de 0,188. O instrutor explica como avaliar o modelo usando a biblioteca de detecção de objetos do TensorFlow e executar o script de avaliação, que gera métricas de desempenho para o modelo treinado. A precisão média e as métricas de recall podem ser visualizadas usando o TensorBoard, uma ferramenta de monitoramento interativa para o TensorFlow.
  
  
• 02:30:00 Nesta seção, o instrutor orienta os visualizadores usando o Tensorboard para visualizar e rastrear métricas durante o treinamento e a avaliação. Ao navegar para a pasta train, eles podem visualizar as métricas de perda ao longo do tempo e, ao acessar a pasta eval, eles podem ver as métricas de avaliação, como precisão média média, precisão e rechamada. Os visualizadores também podem ver o desempenho do modelo em tempo real, visualizando as imagens e se ele as categoriza corretamente, e aprendem como exportar o gráfico após congelá-lo.
  
  
• 02:35:00 Nesta seção, o modelo treinado é carregado a partir do ponto de verificação e a detecção do objeto é realizada em uma imagem. O ponto de verificação mais recente pode ser encontrado na pasta de modelo personalizado, que contém o pipeline e todos os pontos de verificação. Depois que o ponto de verificação mais recente é importado, uma imagem pode ser selecionada e a detecção de objetos pode ser executada usando a função de detecção. A função de detecção também é usada para fazer detecções de objetos em tempo real a partir de uma webcam. Apesar de treinar apenas 2.000 passos com poucas imagens, o modelo tem um bom desempenho na detecção de diferentes gestos das mãos.
  
  
• 02:40:00 Nesta seção, o instrutor demonstra o desempenho do modelo de detecção de objetos em diferentes gestos manuais, como polegar para cima, polegar para baixo, viva longa e mãos duplas. O desempenho do modelo varia dependendo do gesto da mão e da distância da câmera, mas pode ser ajustado adicionando mais imagens ao conjunto de treinamento. Em seguida, a seção passa a congelar e converter o modelo criando um gráfico congelado e exportando-o para TensorFlow.js e TFLite. O modelo convertido pode ser usado para um aplicativo da web ou para um projeto Raspberry Pi. A saída final do modelo personalizado é semelhante aos modelos pré-treinados, com ponto de verificação, ativos de modelo salvos, variáveis e configuração de pipeline.
  
  
• 02:45:00 Nesta seção, o palestrante discute a última conversão que precisa ser feita, que é a conversão para tf light. Isso é feito em duas partes: primeiro, o gráfico é exportado para um gráfico tf lite e, em seguida, é executado usando o conversor tf lite para gerar a saída exata necessária para aproveitá-lo. O palestrante observa que este é o modelo de ponta a ponta e que congelou o gráfico, exportou-o para tfjs e tf lite, concluindo assim o passo a passo completo do trabalho com a API de detecção de objeto tensorflow. O palestrante também discute o ajuste de desempenho e observa três coisas importantes que podem ser feitas para melhorar o desempenho do modelo: adicionar mais imagens de uma classe de baixo desempenho ao conjunto de dados de treinamento, treinar o modelo por mais tempo e alterar a arquitetura do modelo.
  
  
• 02:50:00 Nesta seção do vídeo, o apresentador demonstra como melhorar o desempenho das classes de baixo desempenho no modelo de detecção de objetos adicionando imagens de treinamento mais relevantes. Em vez de coletar imagens de cada classe, o apresentador coleta mais imagens de polegares para cima e polegares para baixo, que não tiveram um bom desempenho com mãos diferentes. O apresentador importa o OpenCV e atualiza o mapa de rótulos antes de coletar apenas imagens de polegares para cima e polegares para baixo. As imagens coletadas são armazenadas no espaço de trabalho do Tensorflow, onde o apresentador as avalia e remove as de baixa qualidade. Por fim, o apresentador adiciona mais algumas imagens de polegares para baixo com uma mão diferente para melhorar o desempenho do modelo.
  
  
• 02:55:00 Nesta seção do vídeo, o instrutor executa o código para capturar mais imagens para os gestos de polegar para cima e polegar para baixo. Depois de capturar as imagens, o instrutor verifica a qualidade das imagens e decide manter todas as imagens de polegar para cima e remove algumas das imagens de polegar para baixo que estão fora da tela. O instrutor então abre a ferramenta LabelImg e rotula as novas imagens novamente, prestando atenção à distinção entre maiúsculas e minúsculas dos nomes dos rótulos. O instrutor menciona que essa etapa de rotular as imagens é de tentativa e erro, e pode-se avaliar e ver o que faz o modelo funcionar melhor. O instrutor sugere procurar ferramentas de rotulagem automática para melhorar a eficiência, mas aconselha prestar atenção ao seu desempenho para evitar a necessidade de ajustes manuais.

Parte 4

• 03:00:00 Nesta seção, o instrutor demonstra como rotular imagens rapidamente para melhorar o treinamento do modelo TensorFlow Object Detection. Ele explica que é importante copiar as imagens rotuladas nas pastas de treinamento e teste para avaliar a precisão do modelo. Em seguida, ele mostra como treinar um modelo "ajustado" alterando o nome do modelo personalizado no notebook de treinamento e detecção para criar uma nova pasta. Em seguida, ele discute como copiar a configuração de pipeline pré-treinada para o novo modelo ajustado e fazer atualizações na configuração de pipeline. Por fim, ele configura todos os caminhos necessários usando o código fornecido para criar os novos arquivos de registro tf necessários para o treinamento.
  
  
• 03:05:00 Nesta seção, o instrutor atualiza a configuração do pipeline que define todos os caminhos do mapa de etiquetas para treinamento usando a configuração padrão. A atualização do pipeline é uma etapa essencial, pois abre caminho para a execução do script de treinamento. O número de etapas de treinamento é atualizado da configuração anterior para 3.000 e o comando é executado para criar o modelo treinado. Após a conclusão das etapas de treinamento, esse modelo é avaliado e comparado ao modelo anterior executando o código na etapa 7. As métricas de avaliação mostram que a precisão média aumentou de 0,7 para 0,834 e a detecção é mais rápida e precisa. Ao adicionar mais imagens, rótulos adicionais e posições diferentes, o instrutor demonstra melhorar o modelo e produzir um modelo de detecção de objetos melhor. Finalmente, o novo modelo é carregado e o código é executado para detecção em tempo real, que detecta objetos com muita rapidez e precisão.
  
  
• 03:10:00 Nesta seção, o instrutor discute maneiras de melhorar o desempenho do modelo Tensorflow Object Detection alterando a arquitetura do modelo. Para fazer isso, o usuário precisa atualizar o link do modelo pré-treinado que deseja usar no notebook de detecção. Ao copiar e colar o novo link e nome, o usuário pode baixar o novo modelo pré-treinado em sua pasta de modelos pré-treinados. No entanto, o instrutor enfatiza que o melhor desempenho é alcançado melhorando a qualidade da imagem, como usar diferentes estilos de imagens, imagens com ângulos diferentes e treinar por períodos mais longos. O instrutor também mostra como treinar um modelo no Google Colab compactando as imagens e arquivando-as antes de importá-las para o notebook de treinamento e detecção no Colab.
  
  
• 03:15:00 Nesta seção, o instrutor orienta os visualizadores no processo de upload de imagens a serem utilizadas no programa de detecção de objetos TensorFlow, bem como na clonagem do repositório de modelos TensorFlow e na instalação do software de detecção de objetos TensorFlow. O modelo pré-treinado é trazido e o mapa de rótulos é criado. O instrutor então estabelece uma configuração personalizada dentro da pasta models/my_ssd_mobnet antes de treinar o modelo. O visualizador é avisado de que a detecção de objetos em tempo real não pode ser feita com uma webcam usando o Colab, mas pode ser feita com uma imagem. À medida que o visualizador avança passo a passo pelo processo, ele pode avaliar seu modelo para ver a precisão média média e a recuperação média.
  
  
• 03:20:00 Nesta seção do vídeo, o instrutor demonstra como detectar objetos em uma imagem usando o modelo treinado. O ponto de verificação mais recente é carregado e o nome da imagem é especificado para executar o script de detecção. O instrutor destaca que a imagem deve ser válida e localizada na pasta de imagens. Depois de executar a célula, o modelo de detecção de objeto treinado identifica o objeto na imagem. O instrutor explica ainda como compactar e exportar os arquivos e enfatiza a necessidade de instalar a API de detecção de objetos ao executar o código localmente. A seção termina com uma prévia dos três projetos que serão abordados a seguir, incluindo o uso de um microscópio para detecção de objetos, a criação de um aplicativo da Web TensorFlow.js e a detecção de sentimentos do Raspberry Pi.
  
  
• 03:25:00 Nesta seção, o instrutor começa explicando o primeiro projeto, que envolve o uso de um microscópio USB para detectar defeitos em pequenos LEDs. O microscópio é tratado como qualquer outra câmera e o feed de vídeo é obtido usando a biblioteca OpenCV. O instrutor demonstra como posicionar e ampliar o microscópio usando o código Python e exibe o feed de vídeo. O feed de vídeo é então usado para coletar imagens de treinamento para detecção de objetos. O objetivo deste projeto é treinar um modelo para detectar defeitos nos LEDs e classificá-los como tortos ou não tortos.
  
  
• 03:30:00 Nesta seção do curso completo TensorFlow Object Detection com três projetos, o instrutor mostra como usar o OpenCV para capturar imagens de uma webcam ou alimentação de microscópio. Ele repassa as melhores práticas para liberar o dispositivo de captura e destruir todas as janelas do OpenCV, incluindo a execução de "cap.release" após fechar qualquer captura da web cv2. Ele então demonstra como ajustar a posição e o foco do microscópio para capturar imagens de pinos de LED e como criar duas novas pastas para armazenar imagens de pinos defeituosos e não defeituosos. Por fim, ele testa o feed da webcam para captura de imagem para garantir que tudo esteja funcionando conforme o esperado.
  
  
• 03:35:00 Nesta seção do vídeo, o instrutor demonstra como coletar imagens de um pino defeituoso e um pino não defeituoso para detecção de objetos. Eles posicionam os pinos e ajustam o tempo de hibernação entre as capturas de imagens e, em seguida, usam a função de hibernação para fazer uma pausa entre as capturas. O instrutor também explica como rotular as imagens usando a linha de rotulagem e o local da pasta. Eles incentivam os espectadores a pedir esclarecimentos ou fornecer feedback na seção de comentários ou no servidor Discord.
  
  
• 03:40:00 Nesta seção do vídeo, o instrutor passa pelo processo de rotular imagens para treinar um modelo de detecção de objeto personalizado usando o TensorFlow. Usando um microscópio, o instrutor captura imagens de pinos defeituosos e não defeituosos e os rotula de acordo. Em seguida, eles copiam as imagens para as pastas de treinamento e teste antes de configurar o pipeline de treinamento. O instrutor explica como eles criarão uma nova pasta para seu modelo de detecção de objeto personalizado e atualizarão o mapa de rótulos para incluir os novos rótulos. A base de código usada nesta seção é bastante geral, permitindo muita personalização, e o instrutor fornece dicas sobre ajuste de desempenho.
  
  
• 03:45:00 Nesta seção do tutorial, o foco está na criação de registros do TensorFlow, que permitem o treinamento do modelo. As células necessárias para baixar modelos pré-treinados e criar mapas de rótulos são discutidas, mas o foco está na criação de registros do TensorFLow que permitirão o treinamento do modelo. Depois que os registros do TensorFlow são criados, o modelo é atualizado com as novas classes e a configuração atualizada é salva. O modelo é treinado para 2.000 etapas e o novo modelo é testado para detectar pinos defeituosos e não defeituosos. O notebook é contornado, e o usuário é direcionado para células específicas que permitem o desenvolvimento desse modelo.
  
  
• 03:50:00 Nesta seção, o instrutor atualiza a imagem para detectar um pino com defeito e um pino sem defeito. O sistema detecta com sucesso ambos os pinos com alta confiança. No entanto, o instrutor percebe que o sistema não funciona bem com o pino defeituoso em uma posição específica, destacando uma troca de ajuste. O instrutor mostra que o quadro de detecção possui parâmetros que podem ser modificados para determinar o nível de precisão da detecção. Ao reduzir o limite mínimo de pontuação, o sistema pode detectar o pino defeituoso razoavelmente bem, mas ao custo de detectar muitas outras coisas como defeituosas. O instrutor testa o sistema com pinos de cores diferentes, inclusive um que não foi treinado, e em ângulo, mostrando a robustez do sistema.
  
  
• 03:55:00 Nesta seção, o instrutor demonstra os resultados do primeiro projeto usando um microscópio como método de detecção de objetos. Ele aponta os pinos detectados e como eles são classificados como defeituosos ou não defeituosos, alterando os ângulos e posições dos pinos. Ele resume o processo do primeiro projeto, que envolve capturar e rotular imagens, montar uma pasta de microscópio e treinar o modelo. O próximo projeto se concentra na construção de um aplicativo da web para detectar a direção de um objeto. Isso envolve a combinação do código do TensorFlow Object Detection Course com o Repositório Github do aplicativo TensorFlow Object Detection. O objetivo é detectar o movimento up-down-left-right que pode ser implantado como um site no futuro.

Parte 5

• 04:00:00 Nesta seção do vídeo, o instrutor explica como definir e redefinir os rótulos para a detecção de objetos do Tensorflow. Em vez de definir rótulos como polegares para cima ou para baixo, ou pinos defeituosos e não defeituosos, eles demonstram como definir movimentos direcionais, como esquerda, direita, para cima e para baixo. Eles então mostram como criar pastas para as diferentes direções e coletar imagens para usar no treinamento. O instrutor também explica como rotular as imagens usando o LabelImg, atentando para os casos de imagem, e sugere o ajuste de desempenho em caso de resultados fracos. Por fim, eles passam a demonstrar como rotular imagens para a direção certa.
  
  
• 04:05:00 Nesta seção do vídeo, o instrutor demonstra como rotular imagens para uso no modelo de detecção de objetos. São utilizadas apenas cinco imagens por objeto/classe, mas o usuário pode ajustar o número conforme desejar. O instrutor informa que este é um processo iterativo e que não há problema em experimentar diferentes números de imagens. Depois que as imagens são rotuladas, elas são classificadas em pastas de treinamento e teste, com uma divisão de 80/20 para cada imagem/aula. Quando as pastas são configuradas, o instrutor altera o nome da pasta e cria um novo caminho de arquivo chamado "direções". Por fim, o instrutor informa que o ambiente virtual já está configurado e não há necessidade de realizar nenhuma etapa extra.
  
  
• 04:10:00 Nesta seção, o mapa de rótulos é atualizado com novos rótulos para "esquerda", "direita", "para cima" e "para baixo" e identificadores exclusivos são atribuídos a cada um. As anotações são executadas para atualizar o mapa de rótulos e gerar os arquivos tfrecord de treinamento e teste necessários. O modelo é então treinado usando um comando para gerar o script de treinamento e a perda é calculada em 0,299. O ponto de verificação 3 é restaurado para importar as dependências para detecções em tempo real e o limite mínimo de pontuação é definido como 90. Finalmente, a webcam é ativada para gerar detecções em tempo real para o modelo de detecção de objetos.
  
  
• 04:15:00 Nesta seção, o instrutor mostra como avaliar o modelo e melhorar sua precisão adicionando mais imagens das classes específicas que não estão tendo um bom desempenho. Ele demonstra isso apontando
  para direções diferentes usando ambas as mãos e vendo como o modelo se comporta. Em seguida, ele congela o gráfico, exporta-o e converte-o em tensorflow.js. Ele também explica como fazer upload do modelo para o IBM Cloud Object Store e percorrer as etapas disponíveis no repositório github. O instrutor então clona o repositório, abre um novo prompt de comando e mostra como navegar para as pastas apropriadas.
  
  
• 04:20:00 Nesta seção do vídeo, o instrutor apresenta passo a passo como preparar um ambiente de desenvolvimento para usar a detecção de objetos do TensorFlow para reconhecimento de imagem. O instrutor primeiro mostra como navegar até as pastas necessárias e clonar o repositório de detecção de objetos do TensorFlow. Em seguida, o instrutor mostra como instalar o Node.js e as dependências do repositório. Por fim, o instrutor demonstra como criar um novo depósito de armazenamento de objeto em nuvem no IBM Cloud e como nomeá-lo. Esse processo é necessário para usar a interface do usuário baseada na Web em seções posteriores do vídeo.
  
  
• 04:25:00 Nesta seção, o instrutor continua com a etapa cinco do tutorial, que é criar um depósito no IBM Cloud Object Storage e fazer upload dos arquivos model.json e .bin nele. Em seguida, ele habilita uma política de acesso público, permitindo que o modelo seja acessado de qualquer local, e mostra como obter a URL do arquivo model.json para uso posterior no aplicativo. Em seguida, ele percorre o processo de ativação do Cross-Origin Resource Sharing (CORS) executando comandos CLI após instalar o IBM Cloud Object Storage CLI.
  
  
• 04:30:00 Nesta seção, o vídeo demonstra como instalar o IBM Cloud CLI e o IBM Cloud Object Storage CLI por meio de uma interface de linha de comando, permitindo o compartilhamento de recursos de origem cruzada (CORS), que permite que um aplicativo da web acesse uma URL de outro lugar. O comando também instala o IBM Cloud Storage Client e o configura com um arquivo de configuração. O vídeo mostra como substituir o nome do depósito de um usuário em um comando que coloca a política de causa na pasta raiz do depósito. Por fim, o vídeo explica que a política de causa está contida no arquivo de configuração da nuvem e faz parte do repositório clonado, o que significa que não é necessária a criação de nenhum arquivo.
  
  
• 04:35:00 Nesta seção, o instrutor explica como atualizar os arquivos necessários para executar o aplicativo web TensorFlow.js. As etapas incluem definir as credenciais do Google Cloud Storage, atualizar o URL do modelo em app.js, atualizar o mapa de rótulos em utilities.js e iniciar o aplicativo usando npm start. O instrutor também explica como depurar o aplicativo se ele não estiver funcionando, incluindo alterar a métrica de confiança e verificar a ordem dos objetos na matriz de resultados da detecção. No geral, essas etapas permitem que os usuários personalizem o aplicativo da Web com base em seu caso de uso específico e garantam que ele esteja sendo executado corretamente.
  
  
• 04:40:00 Nesta seção, o vídeo mostra como descobrir onde os objetos estão e como manipular a matriz de resultados. Ao inspecionar o código, o usuário pode identificar que o array resultante contém cinco valores, e cada array possui classes diferentes que estão disponíveis para um determinado aplicativo. O vídeo ainda orienta o usuário sobre como usar corretamente cada matriz de objeto, como o objeto três, que são classes de caixa não pós-processo representadas por números muito baixos. O vídeo mostra como alterar a métrica de confiança e os valores de pontuação e ajustar o valor da caixa, o que o usuário pode fazer rapidamente alterando os valores da matriz de caixas.
  
  
• 04:45:00 Nesta seção, o vídeo encerra o segundo projeto e segue para o terceiro projeto, que envolve a execução de modelos de detecção de objetos em um Raspberry Pi. O palestrante observa que a execução de modelos de detecção de objetos no Raspberry Pi é diferente dos dois projetos anteriores devido à falta de uma GPU e, portanto, eles converterão especificamente o modelo em um formato Tensorflow lite. Eles coletarão imagens de rostos felizes e tristes e treinarão seu modelo usando o mesmo processo anterior. No entanto, eles usarão o Raspberry Pi para este projeto e usarão a área de trabalho remota para as detecções. O vídeo termina mencionando a possibilidade de executar vários modelos diferentes em diferentes dispositivos e incentiva os espectadores a compartilhar suas ideias sobre o assunto.
  
  
• 04:50:00 Nesta seção do vídeo, o instrutor demonstra como coletar e rotular imagens para um detector de sentimento que reconhece rostos felizes e tristes. O processo envolve deletar imagens existentes, criar caminhos para novas imagens, coletar cinco imagens de cada emoção, rotular as imagens e salvar cada objeto. O instrutor lembra aos espectadores que a distinção entre maiúsculas e minúsculas é crucial na rotulagem e que as telas verdes não são necessárias para este exercício. Além disso, o instrutor observa que os usuários sempre podem retornar ao diretório de imagens para atualizar um rótulo de imagem.
  
  
• 04:55:00 Nesta seção, o instrutor mostra como organizar e mover as imagens e anotações coletadas para as pastas de treinamento e teste. Eles demonstram como criar um novo modelo personalizado e rotular as imagens coletadas como felizes e tristes atualizando o mapa de rótulos. Em seguida, eles criam registros tf e copiam a configuração do modelo pré-treinado para a pasta do modelo personalizado. Após a atualização do config, eles treinam o modelo utilizando o comando gerado, que roda no ambiente virtual, e aguardam a finalização do processo.

Parte 6

• 05:00:00 Nesta seção, o instrutor fala sobre um erro comum que pode ocorrer durante a execução do treinamento do modelo de sentimento ao trabalhar em uma máquina GPU. A mensagem de erro indica que a GPU está totalmente consumida, fazendo com que o sistema passe mal. Para resolver esse problema, os usuários precisam interromper qualquer coisa que possa usar a GPU a qualquer momento e iniciar a execução do treinamento novamente. Após a conclusão do treinamento, os usuários podem importar o sistema operacional e esses caminhos e também verificar o ponto de verificação mais recente. O instrutor também demonstra o uso do modelo de sentimento em tempo real, que é um processo rápido e fácil depois que o sistema é configurado.
  
  
• 05:05:00 Nesta seção, o instrutor explica as etapas necessárias para criar um modelo de detecção de Raspberry Pi usando a detecção de objetos do TensorFlow. A primeira etapa é criar os arquivos TfLite passando pelo curso de detecção de objetos do TensorFlow. Em seguida, os usuários devem clonar o repositório de detecção do Raspberry Pi, baixá-lo para o PC ou cloná-lo do Raspberry Pi. Feito isso, os usuários devem instalar as dependências necessárias, copiar o modelo convertido e executá-lo usando o modelo detect.tf lite existente. O instrutor também demonstra como usar a área de trabalho remota no Raspberry Pi usando xrdp, facilitando o processo.
  
  
• 05:10:00 Nesta seção, o instrutor percorre o processo de instalação de todas as dependências necessárias para trabalhar com a API de detecção de objetos do TensorFlow em um Raspberry Pi. O instrutor demonstra como instalar o OpenCV Python, bem como várias outras dependências necessárias para o OpenCV funcionar no Raspberry Pi. Em seguida, o instrutor instala o tempo de execução do TensorFlow Lite, necessário para executar os modelos do TensorFlow Lite no Raspberry Pi. Depois que todas as dependências são instaladas, elas executam um modelo de detecção de objeto de amostra no Raspberry Pi para mostrar como ele funciona. Por fim, o instrutor explica como adicionar um modelo personalizado e rótulos ao sistema.
  
  
• 05:15:00 Nesta seção, o instrutor discute a detecção de objetos personalizados e como ajustar o limite de detecção para obter melhores resultados. A detecção de objeto personalizado inclui dois rótulos; feliz e triste. O instrutor ajusta a ordem dos rótulos para feliz como o primeiro objeto e triste como o segundo objeto. Ao executar o modelo personalizado, ele não detecta nenhum objeto e o instrutor decide reduzir o limite de detecção para 20%. Após reexecutar o comando, o modelo detecta os objetos; um grande objeto triste e um objeto feliz. O instrutor destaca a necessidade de treinar o modelo com mais imagens para obter melhores resultados de desempenho. O instrutor realiza um ajuste de desempenho adicional adicionando mais imagens das aulas de execução e treinando o modelo por mais tempo.
  
  
• 05:20:00 Nesta seção, o palestrante explica como melhorou o desempenho de seu modelo de análise de sentimento. Em primeiro lugar, ele adicionou imagens adicionais de si mesmo em diferentes ângulos, o que aumenta as chances de o modelo generalizar bem. Em segundo lugar, ele treinou seu modelo para mais 5600 etapas, dando a ele um modelo totalmente novo com um ponto de verificação de índice maior. Ele então converteu esse novo modelo em um gráfico tf-lite congelado e o trouxe para o Raspberry Pi, que ele usou para detectar se estava feliz ou triste. O palestrante demonstra que a tela verde para cima ou para baixo não afetou o desempenho de seu modelo, e conseguiu detectar corretamente quando ele estava feliz ou triste. O palestrante enfatiza o poder do ajuste de desempenho e como ele pode ser usado para melhorar a precisão do modelo.
  
  
• 05:25:00 Este trecho final conclui o curso Tensorflow Object Detection in 5 Hours with Python, com o instrutor lembrando os espectadores de entrar em contato nos comentários ou pelo canal Discord se precisarem de mais ajuda. O curso é benéfico para os visualizadores que desejam aprender sobre detecção de objetos e desejam um conhecimento aprofundado do Tensorflow, pois abrange três projetos dentro do próprio curso.

[MetaQuotes]

Reconhecimento Automático de Placas de Número usando Tensorflow e EasyOCR Curso Completo em 2 Horas | Pitão

Caderno Final: https://github.com/nicknochnack/RealTimeAutomaticNumberPlateRecognition

Código básico: https://github.com/nicknochnack/TFODCourse

Reconhecimento Automático de Placas de Número usando Tensorflow e EasyOCR Curso Completo em 2 Horas | Pitão

O vídeo do YouTube intitulado "Automatic Number Plate Recognition using Tensorflow and EasyOCR Full Course in 2 Hours | Python" fornece um guia abrangente para a construção de um sistema de reconhecimento automático de matrículas (ANPR) preciso e eficiente usando Tensorflow e EasyOCR. O sistema ANPR utiliza um sistema de duas partes, com o TensorFlow sendo usado para detectar a região da placa de interesse, enquanto o EasyOCR extrai o texto da região detectada. O vídeo abrange uma variedade de tópicos, desde a configuração de ambientes virtuais e instalação das dependências necessárias até a preparação de dados para treinamento e solução de erros que podem ocorrer durante o treinamento. No geral, os visualizadores podem obter uma compreensão detalhada de como construir um sistema ANPR de nível de produção com recursos de detecção de imagem padrão ou em tempo real.

O tutorial do YouTube sobre Reconhecimento Automático de Placas de Número (ANPR) com TensorFlow e EasyOCR aborda como detectar placas de carros com precisão usando a detecção de objetos e como extrair os números das placas usando OCR. O instrutor discute como filtrar o texto com base no tamanho e nas coordenadas para extrair apenas as informações relevantes da placa. Eles demonstram como alocar recursos de GPU e limitar o consumo de memória para o TensorFlow, extrair pontuações de imagem, classes e caixas que ultrapassam o limite de detecção e aplicar OCR usando o EasyOCR. Além disso, o vídeo aborda como salvar os resultados de saída em um arquivo CSV e caminho de pasta para resultados em tempo real e de imagem. O palestrante enfatiza que o código está disponível para os espectadores e os incentiva a pedir ajuda e compartilhar seus comentários.

• 00:00:00 sistema é o OCR ou reconhecimento óptico de caracteres. Essa etapa envolve o uso de uma biblioteca chamada EasyOCR para extrair o texto do feed da placa detectada, permitindo ler e analisar o texto das placas em tempo real ou em imagens padrão. Além disso, o curso também aborda a construção de um sistema mais avançado que imita sistemas AMPR pré-construídos para produção, salvando e registrando placas detectadas anteriormente e suas regiões de interesse. No geral, o curso oferece um guia abrangente para a construção de um sistema de reconhecimento automático de placas preciso e eficiente usando o Tensorflow e o EasyOCR.
  
  
• 00:05:00 nesta seção, o apresentador explica o sistema de duas partes usado para reconhecimento automático de placas. A primeira parte utiliza o modelo de detecção de objetos TensorFlow para detectar a região de interesse que é a placa do carro. A segunda parte usa o EasyOCR para extrair o texto da região detectada. O apresentador demonstra como instalar os componentes necessários, incluindo TensorFlow e EasyOCR, e fornece um link para o repositório GitHub contendo os arquivos necessários. O apresentador explica como clonar o repositório e mostra o conteúdo da pasta criada como resultado. A pasta contém um arquivo de notebook que é utilizado para treinamento e detecção da placa.
  
  
• 00:10:00 Nesta seção do vídeo, o apresentador percorre as etapas para configurar um ambiente virtual e instalar as dependências necessárias para executar o Reconhecimento Automático de Placas de Matrícula (ANPR) usando TensorFlow e EasyOCR. O apresentador primeiro clona o repositório ANPR e cria um ambiente virtual com Python. Ele então ativa o ambiente virtual e instala dependências importantes, como o kernel ipi e atualiza o pip. Por meio dessas etapas, ele demonstra como associar o ambiente virtual a um notebook Jupyter para aproveitar todo o poder do ANPR.
  
  
• 00:15:00 Nesta seção, o instrutor conduz o visualizador pelo processo de associação de seu ambiente virtual ao Jupyter Notebook usando o ambiente "ampr sys" como exemplo. O instrutor observa que isso é importante porque muitas vezes as pessoas que trabalham com ambientes virtuais instalam tudo em seus ambientes, mas quando entram no Jupyter Notebook, ainda está dizendo que não está lá. Depois que o ambiente virtual é associado ao Jupyter Notebook, o instrutor orienta o visualizador pelo processo de instalação da API de detecção de objetos do TensorFlow e pela configuração da estrutura de pastas para poder realizar a detecção de objetos usando o TensorFlow.
  
  
• 00:20:00 Nesta seção, o instrutor começa explicando o conceito de aprendizado por transferência, por meio do qual um modelo de última geração já existente pode ser ajustado para um caso de uso específico, como a detecção de placas de veículos. O instrutor então faz o download dos modelos pré-treinados do TensorFlow Model Zoo e instala a API TensorFlow Object Detection executando várias células de código. A API e seus componentes, como a pasta de detecção de objetos, são clonados no repositório do jardim do modelo TensorFlow e a instalação do modelo TensorFlow Object Detection é iniciada. A instalação envolve várias dependências e protoc, o sistema de buffers de protocolo, e pode levar algum tempo para ser concluída.
  
  
• 00:25:00 Nesta seção, o instrutor explica como instalar o TensorFlow e sua versão de GPU. Eles instalam o TensorFlow 2.4.1 e o TensorFlow GPU 2.4.1, que é compatível apenas com GPUs Nvidia. Eles mostram como verificar se a instalação foi bem-sucedida executando um script de verificação, que deve gerar "Ok" no final. O instrutor também demonstra como resolver quaisquer erros de "módulo não encontrado" que possam surgir durante o processo de instalação, como a instalação de bibliotecas Matplotlib e Pillow usando pip. O script de verificação garante que todas as dependências necessárias sejam instaladas antes de passar para a próxima seção.
  
  
• 00:30:00 Nesta seção do vídeo, o apresentador percorre a instalação de vários módulos necessários para a construção de um modelo de detecção de objetos, especificamente para reconhecimento de placas. Eles encontram vários erros durante o processo de instalação, mas explicam como resolvê-los. Uma vez instalados todos os módulos necessários, incluindo TensorFlow Object Detection e EasyOCR, o apresentador segue para a próxima etapa, trabalhando com dados, e apresenta um conjunto de dados Kaggle que contém imagens de carros e anotações para placas de carros. Eles demonstram como baixar e preparar o conjunto de dados para uso no modelo.
  
  
• 00:35:00 Nesta seção, o instrutor discute como baixar os dados necessários para o Reconhecimento Automático de Placas de Número (ANPR) e organizá-los em conjuntos de treinamento e teste para detecção de objetos. Os dados, que contêm anotações e imagens correspondentes, são baixados do Kaggle e descompactados na pasta ANPR. Duas novas pastas são criadas dentro da pasta de imagens, uma para treinamento e outra para teste, e as imagens baixadas são copiadas para a pasta de trem. As anotações também são divididas em conjuntos de treinamento e teste, com as anotações de treinamento sendo colocadas na pasta train ao lado de suas imagens correspondentes. O objetivo desses conjuntos separados é treinar o modelo de detecção de objetos em um conjunto de dados e testá-lo em um conjunto independente para avaliar seu desempenho.
  
  
• 00:40:00 Nesta seção, o vídeo discute o processo de preparação dos dados para treinar um modelo de detecção de placas. O apresentador explica que baixou imagens de placas de veículos do Kaggle e copiou as anotações correspondentes em duas novas pastas, "train" e "test", dentro do espaço de trabalho do TensorFlow. O próximo passo é treinar o modelo de detecção de objetos, que envolve a atualização dos rótulos, criação de registros tf, preparação da configuração e, por fim, treinamento do modelo. O apresentador usa um "mapa de rótulos" para identificar o único rótulo que usará, "licença", e então cria um registro tf, que é o formato exigido pelo modelo de detecção de objetos. O processo é descrito como simples e um script para gerar o registro tf é fornecido.
  
  
• 00:45:00 Nesta seção, o vídeo aborda como preparar os dados para treinamento com TensorFlow e EasyOCR. O script discutido aqui converte os dados brutos, incluindo imagens e anotações, em um formato de registro tf, mas precisa ser atualizado devido ao formato ligeiramente diferente das anotações no conjunto de dados Kaggle. O vídeo mostra como corrigir os erros que surgem devido a essa discrepância, incluindo a instalação de módulos ausentes, a alteração do índice para selecionar as métricas corretas da caixa delimitadora e a cópia da configuração do modelo pré-treinado para a pasta de treinamento.
  
  
• 00:50:00 Nesta seção, o palestrante aborda os detalhes do pipeline de modelo pré-treinado, que contém diferentes linhas de configurações que precisam ser atualizadas antes de treinar o modelo. O palestrante demonstra como copiar o arquivo de configuração atualizado que garante que os parâmetros sejam atualizados e executando o comando de treinamento para treinar o modelo. Eles também mencionam a importância de executar o comando externamente para ver o progresso corretamente e como ativar um ambiente virtual para executar o comando. Por fim, explicam como solucionar um erro padrão que pode ocorrer durante a instalação do modelo.
  
  
• 00:55:00 Nesta seção do curso, o instrutor soluciona erros que podem ocorrer durante o treinamento. Ele demonstra como resolver problemas específicos, como um erro de valor relacionado a uma mudança de tamanho de array de ponto numpy, um erro de módulo não encontrado para cv2, um erro de módulo não encontrado para complementos tensorflow e um erro de módulo não encontrado para gin. O instrutor explica que esses erros não são incomuns e é essencial instalar as bibliotecas necessárias para resolvê-los. Depois que o modelo é treinado, o instrutor mostra como ler as métricas de perda e como encontrar o ponto de verificação do modelo treinado mais recente.
  
  
• 01:00:00 Nesta seção do tutorial em vídeo sobre Reconhecimento Automático de Placas usando Tensorflow e EasyOCR, o instrutor aborda como detectar placas a partir de imagens ou em tempo real usando o mesmo modelo. Ao alterar o nome do arquivo de imagem, o modelo pode detectar e classificar com precisão diferentes tipos de placas. Descobriu-se que esse método tem um desempenho muito melhor por meio da detecção de objetos do que o uso de técnicas tradicionais de visão computacional, pois os formatos das placas podem variar. O modelo também pode detectar placas de uma transmissão de vídeo ao vivo ou segurando um telefone na frente da placa do carro. O instrutor enfatiza que o método é eficiente e é um bom começo para construir um detector de placas de veículos, e o próximo passo seria aplicar componentes de OCR para extrair dados significativos da imagem.
  
  
• 01:05:00 Nesta seção, o tutorial em vídeo discute como usar a biblioteca de código aberto EasyOCR para detectar e extrair texto de uma imagem para identificar o número da placa de um carro. O tutorial observa que, embora existam modelos de OCR mais precisos disponíveis, o EasyOCR é usado conforme executado no PyTorch, exigindo um pouco de espaço para que a GPU possa executá-lo junto com o TensorFlow sem consumir toda a memória da GPU. O tutorial mostra como alocar recursos de GPU e limitar o consumo de memória para o TensorFlow para permitir que o EasyOCR funcione sem problemas.
  
  
• 01:10:00 Nesta seção, o palestrante explica como carregar os caminhos de arquivo e etiquetas necessários para o Reconhecimento Automático de Placas de Número (ANPR) usando TensorFlow e EasyOCR, e como instalar EasyOCR e PyTorch com aceleração CUDA. Eles demonstram que, depois de carregar uma imagem de exemplo e executar o ANPR, os números das placas e as pontuações de detecção são armazenados em uma variável chamada "detecções", que são usadas para aplicar o OCR usando o EasyOCR. Um limite de detecção é definido em 0,7, permitindo que apenas detecções com pontuações acima de 0,7 sejam processadas posteriormente.
  
  
• 01:15:00 Nesta seção, o instrutor explica como extrair pontuações de imagem, classes e caixas que passam do limite de detecção usando algumas linhas de código. Eles demonstram como percorrer cada valor na matriz de pontuação de detecção e retornar apenas as pontuações que ultrapassam o limite. Eles também aplicam filtros às caixas e classes para garantir que tenham o tamanho e o formato corretos para a webcam. Por fim, eles pegam a largura e a altura da imagem para recalcular as coordenadas da caixa e aplicam filtragem na imagem para determinar a região de interesse.
  
  
• 01:20:00 Nesta seção, o vídeo demonstra como extrair a região de interesse da imagem e aplicar o Reconhecimento Óptico de Caracteres (OCR) para extrair os resultados da chapa. Primeiro, os parâmetros de largura e altura da imagem são obtidos usando image.shape. Para extrair o ROI, percorra cada caixa na variável boxes, que representa as coordenadas da detecção, e filtre a região de interesse. Por fim, o OCR é aplicado ao ROI usando o EasyOCR e os resultados são impressos no console. O vídeo orienta o espectador no processo de configuração do leitor EasyOCR, passando pelos parâmetros de idioma e analisando a imagem para extrair os resultados da placa.
  
  
• 01:25:00 Nesta seção, o apresentador discute como extrair efetivamente a placa impressa ou o texto da placa usando OCR (reconhecimento óptico de caracteres). Eles mostram uma imagem de exemplo onde há texto extra além do número da placa, o que pode confundir o leitor de OCR. Para resolver esse problema, o apresentador sugere filtrar os resultados com base no tamanho e nas coordenadas. Eles demonstram como escrever uma função para fazer essa filtragem e aplicá-la à imagem para obter o texto apropriado. Os resultados mostram que o leitor OCR pode extrair com precisão o número da placa, embora ainda haja espaço para melhorias com o modelo OCR.
  
  
• 01:30:00 Nesta seção, o palestrante apresenta uma nova função chamada "filtrar texto". Essa função usa três argumentos: região, o resultado do OCR e o limite da região. A região representa a imagem, o resultado do OCR representa o texto extraído do EasyOCR e o limite da região é o limite de tamanho para detectar as regiões da placa do carro. A função percorre os resultados do OCR, extrai o comprimento e a largura de cada um, multiplica-os e, em seguida, compara-os com o limite da região. Se passar neste filtro, é considerado texto, e sua região é armazenada em uma variável chamada "placa". O palestrante também explica algumas partes do código que calculam o tamanho da região e ilustram como o filtro funciona.
  
  
• 01:35:00 Nesta seção, o autor mostra como filtrar o texto nas imagens de forma eficaz usando o mecanismo de OCR. O algoritmo filterText permitirá que o usuário especifique um limite para a região, que filtrará apenas os blocos de texto que atendem ou excedem esse limite. Eles usam essa função para extrair os componentes de que precisam, em vez de recuperar tudo da placa. Eles também criaram uma função OCR_it que combina o filtro OCR e os componentes OCR e pode ser aplicada a qualquer imagem ao passar a imagem e as detecções com os limites correspondentes.
  
  
• 01:40:00 Nesta seção, o instrutor testa seu método de reconhecimento óptico de caracteres (OCR) passando uma imagem por meio de sua função "ocr_it" com limites de detecção e região especificados. O método é capaz de extrair com precisão a placa e sua região na imagem. Em seguida, eles demonstram a aplicação do método OCR em tempo real para detectar placas de veículos usando um bloco try-except e um novo código que chama a função OCR para cada detecção válida. O instrutor testa a detecção em tempo real em seu telefone e mostra que detecta e extrai com precisão o texto da placa do carro, embora os resultados não sejam perfeitos e possam precisar de alguns ajustes.
  
  
• 01:45:00 Nesta seção do vídeo, o instrutor explica como salvar os resultados de saída do sistema OCR que eles desenvolveram. Eles criam uma nova função chamada "save_results" que usa o texto, a região, o nome do arquivo e a pasta como parâmetros de entrada. Eles então usam a biblioteca uuid para gerar um nome de arquivo exclusivo e a biblioteca csv para salvar os resultados de saída em um arquivo csv. Eles também usam a biblioteca cv2 para gravar a imagem na pasta selecionada. Por fim, eles encerram o código e o testam.
  
  
• 01:50:00 Nesta seção do vídeo, o instrutor demonstra como configurar um arquivo CSV e um caminho de pasta para gravar todos os resultados ou regiões da imagem. Eles criam uma nova pasta chamada detection_images, onde todos os resultados da imagem serão gravados. O instrutor mostra como passar pelo nome do arquivo CSV e caminho da pasta e, em seguida, testar o código para salvar os resultados. Eles configuram um método de salvamento de resultados para gravar os resultados na pasta criada, que inclui o nome da imagem, bem como o número da placa. O instrutor então demonstra como executar o código em tempo real para salvar os resultados enquanto as detecções estão acontecendo. Por fim, eles testam o código, o que resulta na saída precisa das imagens enquanto salva os resultados em tempo real.
  
  
• 01:55:00 Nesta seção, o palestrante informa aos espectadores que a função OCR construída e o algoritmo de filtragem aplicado em tempo real estão disponíveis para eles. Ele incentiva os espectadores a pedir ajuda caso enfrentem alguma dificuldade e menciona que o código estará disponível no GitHub para uso. Por fim, ele agradece aos espectadores por sintonizar, pede que gostem, se inscrevam e comentem e desligam.