Respostas no Fórum
- Posts
Olá Douglas!
Modelos deep learning para detecção de pose como esse usado na aula podem ser bastante pesados para rodar em tempo real, principalmente em dispositivos com recursos computacionais limitados, mas também depende muito de outros fatores como o tamanho do vídeo por exemplo.
Para uma aplicação comercial em tempo real, o uso de modelos como esse dependerá muito da estrutura computacional empregada. A recomendação seria utilizar uma GPU de alta performance, que pode processar as inferências de forma paralela, o que reduziria significativamente o tempo de resposta. GPUs como as da série NVIDIA RTX ou Tesla são amplamente usadas em cenários de inferência de visão computacional. Em dispositivos móveis ou mais simples, é possível explorar versões otimizadas de modelos de detecção de poses, como as implementações leves do TensorFlow Lite ou MediaPipe, que são mais apropriadas para aplicações em tempo real e têm menor demanda por recursos computacionais.
Portanto, é viável rodar detecção de movimentos em tempo real em aplicações comerciais, mas para isso é essencial garantir uma infraestrutura otimizada, preferencialmente com aceleração por hardware (GPU), e escolher um modelo pré-treinado que esteja balanceado entre precisão e velocidade de execução.
Hoje há modelos mais otimizados para essa tarefa, como por exemplo o estimador de poses do YOLO https://docs.ultralytics.com/tasks/pose/
a sua arquitetura e o modelo são baseados em abordagens mais modernas, portanto conseguem rodar tranquilamente em tempo real.
Olá José!
Para resolver esse erro, basta trocar cv2.imshow por cv2_imshow, pois o nome da função de exibição de imagem usada no Colab é cv2_imshow (com “_” e não “.“) . Ou seja, apenas fazendo essa correção no código deve funcionar.
Olá Douglas!
Os Autoencoders possuem diversas aplicações na visão computacional, mas seu principal uso não é a compressão de vídeos diretamente, como você mencionou. Eles são redes neurais usadas para reduzir a dimensionalidade de dados complexos e aprender uma representação compacta (codificação) de entradas, que pode ser utilizada em uma variedade de tarefas, como detecção de anomalias, remoção de ruído em imagens, e até mesmo geração de novos dados a partir de uma codificação comprimida.
Em uma aplicação comercial, um autoencoder poderia ser usado, por exemplo, para reduzir o tamanho de dados de imagens ou vídeos, mas isso geralmente não seria a solução mais eficiente ou direta para compressão de vídeos. Algoritmos de compressão específicos, como H.264, são otimizados para essa tarefa. No entanto, autoencoders podem ser úteis em outras situações, como detectar padrões ou anomalias em imagens médicas ou industriais, ou ainda para pré-processar dados visuais para outras tarefas de aprendizado de máquina.
Se o seu objetivo for compactação de dados visuais então um autoencoder até pode ser aplicado, mas provavelmente ele não será a solução mais eficiente para compressão de vídeo em comparação com codecs de compressão tradicionais por exemplo.
Para completar, alguns exemplos de aplicações e casos de uso:
- Compressão de imagens e áudio — Autoencoders reduzem o tamanho de arquivos grandes ao aprenderem a comprimir e reconstruir imagens ou áudios, preservando as informações essenciais.
- Detecção de anomalias — Eles identificam irregularidades nos dados, comparando o quão bem conseguem reconstruir entradas em relação a padrões normais.
- Redução de dimensionalidade — Eles simplificam dados de alta dimensionalidade em uma forma mais compacta, mantendo as características principais.
- Geração de dados novos — Autoencoders podem gerar novos dados semelhantes aos existentes, decodificando representações comprimidas.
- Remoção de ruído — Eles removem ruído dos dados ao aprender como restaurar o conteúdo original a partir de entradas com ruído.
- Sistemas de recomendação — Para personalizar recomendações ao analisar e comprimir preferências dos usuários para prever interesses futuros.
Olá!
Para instalar o OpenCV no Linux você pode usar o gerenciador de pacotes pip, que é utilizado várias vezes ao longo do curso para baixar bibliotecas no Python.
Recomendamos instalar a versão do OpenCV que inclui os módulos extras (contrib), pois ela vem com funcionalidades adicionais, como os métodos de reconhecimento facial e outras ferramentas úteis que não estão presentes na versão padrão do OpenCV. Ou seja, será essencial caso queira implementar a seção de reconhecimento facial.
Com o terminal aberto, execute o seguinte comando para instalar o OpenCV com os módulos contrib:
pip install opencv-contrib-python
Se estiver usando o Pycharm, tem um modo melhor ainda. Vá em: File > Settings > [Selecione o projeto] (Project) e abra Project Interpreter. No lado superior direito clique em “+”. Pesquise na lupa por “opencv-contrib-python” e clique em “Install”.
Antes só verifique se a versão correta do Python está selecionada em Project Interpreter (File > Settings > [Selecione o projeto] (Project) => Project Interpreter).
Olá Douglas!
Na linha que ocorreu o erro, troque .input por .get_layer(‘conv2d’).input
e também faça a troca no método Model() que está na linha logo na sequência.
Na dúvida, acesse o Colab compartilhado na aba “Materiais” dentro da primeira aula dessa seção sobre Autoencoders, eu rodei aqui novamente e funcionou conforme esperado (nesse Colab já está atualizado essa linha de código).
Isso ocorre em razão de uma atualização recente do tensorflow, onde é necessário um pequeno ajuste. Alternativamente, você tem a opção de usar uma versão anterior, desse modo não precisa fazer esse ajuste nessa linha de código. Se optar por usar uma versão um pouco anterior (por exemplo a 2.12.0) então basta rodar esse comando abaixo antes de todo o código, colocando como o primeiro bloco.
!pip install tensorflow==2.12.0
E após executar isso reiniciar a sessão do Colab. Caso não apareça já automaticamente um botão para reiniciar, basta ir em ‘Ambiente de execução > reiniciar sessão’. Com isso vai funcionar e não precisa fazer nenhum ajuste.
Olá Robson!
Esse aviso aparece porque para usar a API da OpenAI é necessário pagar pelo uso, eles não oferecem mais uso gratuito através desse modo.
Para acessar as informações de cobrança e adicionar um método de pagamento para acessar a API, visite https://platform.openai.com/settings/organization/billing/overviewDá para começar com apenas U$5,00, o que parece pouco mas só isso já garante bastante uso mesmo. Consulte a página https://openai.com/api/pricing/ para verificar quantos centavos de dólar são necessários para cada milhão de tokens processados.
Lembrando que o método com o Hugging Face Hub mostrado no curso é gratuito, então pode usar ele para começar caso se sinta mais confortável, e depois que estiver com sua aplicação devidamente testada e ajustada você pode escolher uma opção paga como a Open AI.
Quanto a esse erro com o Ollama, pode ocorrer por vários motivos, mas geralmente é devido a alguma etapa na instalação e configuração ou até mesmo alguma configuração no sistema operacional e que bloqueia a conexão.
Ao seguir a aula “Execução local com Ollama”, apareceu algum erro para você?
Experimente abrir novamente o terminal conforme mostrado em aula, e execute ollama run phi3 (ou o outro modelo que estiver querendo usar) e após terminar de rodar o processamento no terminal volte a executar o código .py pelo VS code. E verifique também se o seu Ollama está atualizado e na versão mais recente.
Olá Leandro!
Aumentar o tamanho da imagem é útil se o objeto a ser detectado tiver detalhes finos que são importantes para a correta classificação. Isso ocorre porque imagens maiores podem capturar melhor esses detalhes, permitindo que o classificador aprenda características mais sutis. Também é benéfico quando o objeto é pequeno em relação ao fundo (entre as imagens usadas para treinamento e teste) e precisa de mais resolução para ser identificado corretamente.
Aumentar o número de imagens positivas é indicado no geral para que o classificador aprenda a detectar com mais precisão, pois isso dá mais exemplos de como o objeto aparece em diferentes condições (iluminação, ângulos, variações), melhorando a sua generalização. Para um classificador realmente bom recomenda-se utilizar umas 5000 imagens (não é exigido tudo isso, pode usar metade ou até menos em seus testes iniciais, mas aqui quanto mais imagens melhor. Só lembrado que isso pode deixar o treinamento muito lento). Então, a verdade mesmo é que não há uma regra de quantas utilizar.
Um detalhe importante também é sobre a qualidade das imagens usadas no treinamento, se estão em uma resolução boa e nítida e com bastante variações por exemplo. Um classificador com 1000 imagens bem selecionadas pode ser melhor que um com 5000 imagens “ruins”, que podem acabar confundindo o modelo. Se você quer um classificador mais robusto (que atenda uma grande variedade de cenários e situações) então será necessário coletar manualmente imagens positivas desse objeto sob diferentes condições. Para objetos mais rígidos (como uma logo) da para usar apenas o createsamples para gerar amostras a partir das imagens de treinamento.
Já aumentar o número de imagens negativas é fundamental caso esteja cometendo muitos erros falsos positivos (identificando coisas que não são o objeto como sendo o objeto). Desse modo o classificador consegue aprender melhor a distinguir entre o que é e o que não é o objeto-alvo.
Ou seja, a escolha ideal do que alterar depende dos desafios específicos que você está enfrentando nos experimentos com o treinamento.
Para mais detalhes sobre como ajustar os parâmetros de treinamento e sobre como melhorar o desempenho, consulte a aula “Melhorias e parâmetros haarcascades”.
Olá João!
No YOLOv8 são disponibilizados modelos pré-treinados em diferentes tamanhos, como por exemplo o Nano (YOLOv8n) e o Small (YOLOv8s).
A ideia é a mesma, usá-los como “ponto de partida”, mas a diferença é que o v8 permite treinar modelos em arquiteturas de diferentes tamanhos, então você pode ter essa opção para escolher. Isso é explicado detalhadamente na seção “YOLOv8”, recomendo dar uma olhada caso ainda tenha dúvidas pois lá explica o conceito dos tamanhos e mostra o código para implementação do treinamento.
Olá!
Primeiramente, vocês podem também executar pelo Colab usando apenas CPU ou localmente sem GPU, basta usar o Hugging Face Hub conforme explicado na aula “Outros serviços para modelos”. Isso te permite rodar modelos LLM de forma prática, mesmo sem hardware adequado. Outra alternativa seria se conectar via API usando LLMs pagas, como a Open AI (mas pelo Hugging Face Hub você pode fazer isso gratuitamente).
Já se quiser usar com a GPU do seu notebook é necessário que a biblioteca CUDA esteja corretamente instalada e configurada. A GeForce MX450 é compatível com CUDA, mas você precisa garantir que os drivers da NVIDIA e a versão correta do CUDA Toolkit estejam instalados.
Primeiro, verifique se o PyTorch está compilado com suporte para CUDA. Você pode instalar o PyTorch com a versão CUDA compatível através do comando de instalação presente no site oficial do PyTorch (https://pytorch.org/) – abaixo de “Install PyTorch”.
Oi! Não se preocupe, esse é um tema que parece meio confuso mesmo e pode demandar certo tempo para adquirir a intuição necessária, então fique tranquila que durante o processo de aprendizagem vai fazer mais sentido para você 😉
Mas quanto à duvida, sim, acredito que você pode sim combinar as duas técnicas para alcançar seu objetivo. Para localizar os pontos de interseção no gráfico, uma abordagem eficaz seria realizar um pré-processamento usando técnicas de visão computacional e processamento de imagem conforme comentei na resposta anterior, como a detecção de bordas com OpenCV, desse modo permitindo você encontrar automaticamente essas interseções. A partir daí, você extrai as coordenadas (x, y) dos pontos de interseção.
A U-Net, por outro lado, poderia talvez ser usada para gerar a segunda imagem, ou seja, o gráfico final. Nesse caso, uma sugestão também seria procurar por papers que usam U-Net (ou outra rede) para reconstruir uma imagem com base na imagem original, estudar a real possibilidade disso na prática, pois creio que pode servir de inspiração (sugiro procurar nos repositórios por termos em inglês, como “unet image reconstruction”).
A U-Net é poderosa mesmo para segmentação de imagens, mas para a tarefa de encontrar as coordenadas exatas, métodos tradicionais de processamento de imagem podem ser mais adequados. Uma vez que você tenha as coordenadas das interseções (obtidas via processamento de imagem), pode utilizá-las para gerar o novo gráfico, traçando as linhas no local correto.
Para reconstruir esse gráfico a partir dos pontos de interseção que você extrair (coordenadas x, y), será necessário implementar um algoritmo que transforme esses valores em uma visualização gráfica. Esse algoritmo será responsável por organizar os pontos em uma estrutura coerente para o traçado da curva ou das linhas desejadas. Uma vez que você tenha as coordenadas, uma ótima opção é utilizar bibliotecas como Matplotlib ou Seaborn, que são amplamente usadas em Python para visualização de dados. Elas permitem gerar gráficos de alta qualidade e personalizáveis, garantindo imagem precisa e clara.
Ou seja, em seu projeto você vai usar uma combinação de diferentes bibliotecas, como as abaixo (ou outra de sua preferência, com o mesmo objetivo)
- OpenCV para o pré-processamento da imagem (detecção de bordas com cv2.Canny() ou cv2.findContours() para detectar as curvas).
- NumPy para lidar com os arrays de coordenadas.
- Matplotlib para gerar o novo gráfico com base nas coordenadas extraídas dos pontos de interseção.
- TensorFlow/Keras ou PyTorch para treinar e usar a U-Net, caso você precise de uma abordagem mais robusta para segmentação de imagem.
Portanto, uma solução pode ser: (1) pré-processar a imagem para detectar os pontos de interseção, (2) extrair as coordenadas desses pontos e (3) usar essas coordenadas para gerar um novo gráfico com Matplotlib ou outro pacote de visualização. Isso evitaria a necessidade de uma rede neural para a parte de detecção das interseções, simplificando o processo.
Olá Douglas!
Isso é devido a uma atualização recente do tensorflow, onde é necessário um pequeno ajuste. Na verdade, você tem duas opções: ou usar uma versão anterior, ou fazer esse ajuste.
Se optar por usar uma versão anterior (por exemplo a 2.12.0 — mas pode ser mais recente, só não pode ser uma das últimas) então basta rodar esse comando abaixo antes de todo o código, colocando como o primeiro bloco.
!pip install tensorflow==2.12.0
E após executar isso reiniciar a sessão do Colab. Caso não apareça já automaticamente um botão para reiniciar, basta ir em ‘Ambiente de execução > reiniciar sessão’. Com isso vai funcionar e não precisa fazer nenhum ajuste.
A outra opção é fazer um pequeno ajuste. Após uma atualização recente do tensorflow é necessário agora usar get_layer() para a camada de input, igual é feito com a camada de output.
Ou seja, ao invés de autoencoder.input agora vai ser: autoencoder.get_layer(‘dense’).input
você deve substituir isso no parâmetro inputs em “encoder = Model()“. ficando assim:
encoder = Model(inputs = autoencoder.get_layer(‘dense’).input, outputs = autoencoder.get_layer(‘dense_2’).output)
Observação: além desse trecho, também será preciso mudar lá logo abaixo da seção “Codificação e decodificação das imagens de teste”, alterando de autoencoder.input para autoencoder.get_layer(‘conv2d’).input
Olá, eu acredito que conseguiria sim reconstruir a imagem usando técnicas tradicionais (isso se entendi corretamente o que você quis dizer que “reconstruir”, que seria criar esse gráfico que você mandou por último). Caso o interesse seja segmentar a linha (e não apenas retornar a localização do ponto de intersecção) então teria vantagem usar o U-Net ou outra abordagem para segmentação de imagem, pois através da segmentação você retornaria o desenho da linha no gráfico, já com detecção você poderá obter somente a região do ponto de intersecção na imagem e as coordenadas dessa região de interesse (ROI).
Mas caso você precise apenas achar o ponto x,y na imagem e não segmentar a linha então penso que a U-Net não teria uma vantagem nesse contexto, já que o retorno da U-net no final das contas é basicamente uma máscara do “objeto” segmentado (nesse caso, objeto é o ponto de intersecção). Ou seja, ao final do processamento da rede neural você terá uma imagem binarizada que representa o “objeto” com um cor e o fundo (tudo o que não é o objeto) com outra. Mas talvez tenha outro detalhe em relação ao que você deseja fazer e que faça o U-Net ser mais vantajosa, essa minha opinião acima seria com base apenas no que entendi quanto à questão que você apresentou na pergunta.
Mesmo assim, se ideia é segmentar a região eu aconselho testar também as técnicas tradicionais mostradas na primeira seção do curso, por exemplo a técnica de limiarização (thresholding). É um método mais simples mas que pode ser bastante eficaz para imagens digitais, que possuem menos variação de tons de cores. Aliás, se todas as imagens que você fará o processamento forem semelhantes e possuírem o mesmo estilo de gráfico por exemplo, então esses métodos tradicionais podem ser o suficiente. Já se as imagens de gráficos que serão testadas possuírem muitas diferenças entre si então faz mais sentido usar técnica baseada em deep learning como U-Net, pois irão ser mais robustas e funcionar melhor para uma gama maior de imagens e sem exigir customização individual de parâmetros.
Quanto à possibilidade de extrair as coordenadas desse segmento na imagem, dá para fazer isso tanto usando os métodos com deep learning quanto métodos com processamento de imagem (por exemplo assim). Ou seja, de qualquer forma poderá obter as coordenadas de localização desse ponto na imagem, podendo usar para gerar uma imagem semelhante à que você forneceu. E para obter esses valores dos eixos X e Y em uma imagem de gráfico, é possível usar técnicas de processamento de imagem como detecção de bordas ou contornos para identificar elementos relevantes, como curvas ou interseções (ou a técnica de limiarização, que citei acima). Uma vez detectado o ponto de interesse – nesse caso, ponto de interseção – as coordenadas desse ponto podem ser extraídas em termos de pixels. Com essas coordenadas em pixel, você pode realizar uma calibração comparando os pixels com os valores reais dos eixos. Isso é feito associando pontos de referência conhecidos no gráfico aos seus valores correspondentes no eixo (por exemplo, associar um ponto específico no gráfico ao valor de 3.5 no eixo X e 1 no eixo Y). Dessa forma, é possível converter as coordenadas de pixel em valores reais do gráfico, permitindo a leitura precisa das variáveis como tempo (Y) e velocidade (X).
Uma outra sugestão seria que você combine ambas as abordagens: comece com o processamento de imagem tradicional para pré-processar ou até mesmo identificar os pontos de interesse, e, em seguida, use uma U-Net ou outra rede neural adequada para mapear essas interseções e depois poder gerar a imagem final do perfil de velocidade.
Olá João!
Segue abaixo a explicação para cada função de loss / perda:
- Box loss – mede o quão bem o modelo prevê a localização e o tamanho das caixas delimitadoras previstas pelo modelo (x, y, largura, altura) em relação às coordenadas reais (da ground truth) que encapsula o objeto. Portanto, mede a discrepância entre a caixa delimitadora prevista e a real, indicando a importância de obter a localização correta da bbox com o mínimo de erro.
- Cls (Class) loss – está relacionada à tarefa de classificação, que corresponde à classificação correta dos objetos. É a diferença entre a classe prevista de um objeto pelo modelo e a classe real do objeto (indicado no arquivo de anotação usado para treinamento). Aumentar esse valor diz ao modelo para prestar mais atenção em obter as classificações corretas, potencialmente melhorando a precisão onde ocorre identificação incorreta.
- DFL loss – Significa ‘Distribution Focal Loss’, que é uma variante da focal loss (detalhada nesse artigo) que ajuda a melhorar o desempenho do modelo quando os dados de treinamento são desequilibrados. Especificamente, isso é usado para lidar com o desequilíbrio de classe (class imbalance) que surge ao treinar em conjuntos de dados com objetos muito raros. Quando há muito poucos exemplos de uma determinada classe de objeto no conjunto de treinamento, a rede pode normalmente ter dificuldade para aprender a detectar esses objetos corretamente. Essa perda visa abordar esse problema e garantir que o modelo detecte corretamente esses objetos mais raros.
Para mais informações você pode conferir a documentação do YOLOv8: https://docs.ultralytics.com/reference/utils/loss
Na documentação eles não detalham muito sobre cada loss especificamente, mas se quiser saber onde encontrar mais detalhes sobre a explicação você pode procurar em discussões no repositório oficial, que contém informações do autor (fonte dessas informações acima por exemplo: [1], [2], [3], [4], [5]).
Olá Amanda!
Sim, é possível treinar uma rede neural para identificar a região de interseção como a na imagem que você passou. Esse tipo de problema pode ser abordado como uma tarefa de detecção ou segmentação de objetos, onde o objetivo é localizar ou destacar a área de interesse. Ou ainda, focando em usar um conjunto de técnicas de processamento de imagem para se obter a localização exata da região.
Uma abordagem usando redes neurais e deep learning seria criar um conjunto de dados anotado onde as áreas de interseção são marcadas manualmente, permitindo que a rede aprenda a identificar essas características durante o treinamento. Como você já tem algum conhecimento teórico sobre Redes Neurais Artificiais, a próxima etapa seria aplicar esse conhecimento em um projeto prático. Um detalhe apenas é que essa abordagem seria um pouco mais trabalhosa pois tem que reunir um bom conjunto de imagens de treinamento, mas é possível sim.
Para aprender a treinar uma rede neural do zero, recomendo focar em cursos que abordam a criação e treinamento de modelos de deep learning na prática, de preferências cursos focados em visão computacional. O curso “Visão Computacional – O Guia Completo” poderia ser uma boa escolha para agora, mas sugiro dar uma olhada antes nos outros da trilha de visão computacional para ver se a grade de algum deles pode ser mais adequada ao que você procura (e também para ver em qual nível de conhecimento você estaria).
Embora seja possível treinar uma rede neural para detectar a interseção na imagem, penso que pode ser mais prático e eficiente utilizar técnicas tradicionais de processamento de imagem para essa tarefa específica. Métodos como detecção de bordas, segmentação baseada em limiar (thresholding), ou transformadas como a Transformada de Hough, que são frequentemente usados para identificar formas geométricas em imagens, podem ser suficientes para resolver esse problema de maneira precisa e rápida. A vantagem é que além dessas técnicas requerem menos recursos computacionais, também podem ser mais facilmente interpretadas e ajustadas para detectar interseções em imagens como a que você está trabalhando. Ou seja, mexendo nos parâmetros do algoritmo (que pode ser facilmente implementado pela função pronta) você conseguiria adequar ao seu exemplo.
Esse aqui é um exemplo de como poderia ser usado, não é tão semelhante ao seu exemplo mas a ideia é basicamente a mesma, sendo usado para achar a intersecção. Ali já tem o código pronto, porém pode ser necessária uma customização dos parâmetros para se alcançar o resultado ideal.
Portanto, por exigir menos trabalho que o treinamento de um modelo próprio eu recomendaria testar antes essas abordagens.
Aliás, boa sorte em seu projeto!
