Forum Replies Created
- Posts
Olá Diogo!
Nesse caso eu recomendo instalar o OpenCV diretamente pelo Pycharm, pois evita esse tipo de problema. Para isso, 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).
Caso não funcione experimente desinstalar o OpenCV antes (através do comando pip uninstall) e instale novamente.
Olá Valdemar,
Tem como sim, você pode ter ao mesmo tempo em sua máquina vários ambientes virtuais, com até mesmo versões diferentes do Python em cada uma delas, e em cada ambiente você mantém a versão desejada das bibliotecas. Você pode fazer isso através do próprio Anaconda (nas aulas de implementação no Windows é mostrado como usá-lo, mas se quiser veja aqui).
Olá!
A detecção é feita em escala de cinza pois o algoritmo espera imagens assim, e além disso em escala de cinza tem menor informações e portanto o desempenho será melhor.
Se você não fizer a conversão para escala de cinza antes de passar a imagem para o cascade (ou seja, passar a imagem com canais de cor) então isso será reconhecido pelo algoritmo e essa conversão será feita em uma etapa posterior, executada pela função detectMultiScale().
Por isso que se você não fizer a conversão pode ser que obtenha diferentes resultados (mas eles tendem a ser mínimos). Isso porque a função de conversão para escala de cinza usada provavelmente difere da função de conversão interna usada pelo método que usamos para implementar o cascade, pois há uma infinidade de funções para conversão de imagens com 3 canais de cores para 1 canal de cor, como pode ser visto nesse exemplo (pode ver que dependendo da função, certas regiões podem ficar com um tom de cinza mais escuro ou mais claro. e se por exemplo a “confiança” de uma determinada detecção estiver perto do limiar então uma pequena diferença no tom de luminosidade de certas regiões pode ser um fator decisivo para que o cascade classifique ou não determinado objeto).
Mas no fim, o cascade se baseará numa versão em escala de cinza da imagem, pois eles foram treinados em escala de cinza, além de que toda a sua abordagem em si se baseia na diferença de iluminação na imagem e portanto é uma técnica que por padrão não leva em consideração tons de cores nesse caso.
Veja abaixo um artigo se quiser ver o comparativo e mais detalhes sobre as duas abordagens: https://www.researchgate.net/publication/255798161_Face_Detection_on_Grayscale_and_Color_Images_using_Combined_Cascade_of_Classifiers
E quanto ao tamanho, simplesmente não há uma regra exata. O “melhor” tamanho é escolhido com base numa avaliação entre desempenho (muito grande começa a ficar bem pesado) e também considera-se o tamanho mínimo indicado a se usar para que detalhes importantes na imagem não sejam perdidos. Por exemplo, se sua imagem contém detalhes pequenos e o cascade deve detectar esses objetos pequenos então não dá para diminuir tanto a imagem, mas você pode reduzir sim até um ponto onde o cascade seja capaz de detectar. Por isso também que reduzir ou não a imagem pode fazer com que certos objetos sejam detectados ou não, mas as vezes apenas ao redimensionar a imagem faz com que influencie a detecção de objetos que estão num tamanho “normal” – mas aí se estiver apresentando resultados incorretos então é o caso de você precisar calibrar melhor os parâmetros da função detectMultiScale().
Enfim, não há uma regra de melhor tamanho, mas seguindo essas dicas e através de testes você consegue chegar no tamanho mais adequado para a sua situação.
Olá Victor!
Já estamos analisando aqui. Se possível, compartilhe o seu Colab.
Pelo que parece, tem a ver com a versão do Tensorflow, que durante a sessão não foi trocada para a 1.x. Se precisar, enquanto isso você pode usar o Mask R-CNN para a versão 2.x do Tensorflow, basta usar esse repositório ao invés do usado na aula.
Olá Jardel!
Para capturar as imagens de um vídeo basta fazer uma alteração no parâmetro da função “VideoCapture()”, lá na aula passamos o valor 0 pois corresponde ao “índice” do dispositivo de câmera a ser usado pelo OpenCV (nesse exemplo, a própria webcam), então por padrão é 0. Mas se ao invés de fazer a leitura em tempo real pela webcam você quer ler os frames de um arquivo de vídeo então basta você trocar o parâmetro, ao invés do número você vai colocar o caminho para o arquivo de vídeo
por exemplo: cv2.VideoCapture(“video1.mp4”)
onde video1.mp4 é o nome do arquivo de vídeo. E lembre de colocar o caminho correto, em relação à raiz do seu projeto (então se por exemplo o arquivo de vídeo está dentro de uma pasta chamada “videos” precisa colocar lá assim “videos/video1.mp4”).
E para capturar a cada 1 segundo, basta colocar uma condição para que ele salve a imagem somente após passar 1 segundo, ou a cada x frames por exemplo.
Olá Jardel!
Não tem um número ideal, os autores dessas 3 abordagens até não recomendam um número aproximado, mas a partir dos diversos testes feitos nós sugerimos manter um número entre 20 e 80 fotos. Mas nada impede de testar depois com mais também, pois as vezes pode funcionar melhor para o seu cenário.
E importante notar que a qualidade das fotos nesse caso pode ser muito mais importante do que a quantidade, pois não adianta por exemplo colocar 1000 fotos de treinamento se elas não seguirem as condições ideais (aquelas dicas que damos nas aulas, por exemplo: iluminação boa, verificar se a face está nítida, etc.)
Para essas abordagens mais clássicas, muitas vezes acaba sendo um trabalho de ‘tentativa e erro’ no começo, até calibrar bem. Então você poderia iniciar com umas 25 fotos por exemplo e ir testando como está a precisão do algoritmo; caso ele não funcione bem para diferenciar mais duas pessoas (que podem ou não ser parecidas) então você vai aumentando a quantidade de fotos por pessoa e assim retreina os algoritmos. E teste com os 3, apesar de que o LBPH se mostrou mais robusto para cenários mais reais (e cenários que não sejam extremamente controlados) então foque nele.
Olá Filipe!
Depende da arquitetura, na verdade não tem uma regra exata quanto ao número de neurônios. No caso das camadas fully connected, o número de neurônios não está relacionado ao número de unidades na camada anterior por exemplo, você poderia hipoteticamente até colocar um FC com 1 neurônio após uma camada com 10.000 neurônios. Ou seja, são valores que dependem de uma escolha de arquitetura.
Já se sua dúvida é dentro do contexto da YOLO, você pode obter esses e outros detalhes sobre a arquitetura nesse artigo. Basicamente, ele usa como backbone o CSPDarknet53, cujo número de camadas (e outras informações específicas sobre cada uma elas) você obtém aqui. Aliás, esses detalhes mais específicos sobre a arquitetura e o modelo usado estão presentes no paper original do YOLOv4, porém para uma leitura um pouco mais explicativa sugiro aquele primeiro artigo que citei, ou até mesmo esse post da Roboflow.
Olá Samuel!
Para a versão 1.5.3 você precisa usar o código que está dentro de Personagens NOVO.zip, e não do Personagens antigo.zip conforme você indicou.
O .zip “antigo” é para rodar nas versões mais antigas do JavaCV (pois esse 1.5.3 foi lançado depois da publicação do curso e exigiu mudanças no código, portanto foi disponibilizado as alterações que precisam para rodar nessas versões mais novas).Dentro do arquivo .zip que contém todo o material da aula vai ter esse arquivo com o nome Personagens NOVO.zip
Basta descompactar esse arquivo e dentro dele você vai ver que além do documento (em word) que explica cada uma das alterações vai ter também os JARs da versão 1.5.3 e o projeto Netbeans contendo o código já pronto (dentro da pasta “ReconhecimentoPersonagens”).
Já se você procura pelo arquivo específico do código .java atualizado então você vai encontrar dentro do próprio diretório do projeto, mais especificamente em:
ReconhecimentoPersonagens/src/opencv/Caso ainda assim dê algum erro para você, peço que verifique se foi adicionado todos os JARs (conforme mostra na imagem dentro do arquivo word) e se ainda assim mostrar erro então poste aqui a mensagem de erro exata que aparece para você, que nós iremos te auxiliar.
Olá Tiago!
Para ter uma noção melhor, sugiro olhar a página “Trilha de Visão Computacional”, dentro da página de Trilhas de Aprendizagem (link aqui).
São dezenas de cursos e as técnicas e abordagens podem variar muito em cada um, porém nessa trilha é reunido todos eles e é mostrado o “caminho” indicado a ser seguido. Você pode seguir esse caminho ou se preferir pode ver a descrição do curso e escolher aquele que aborda a necessidade que você precisa para resolver o seu problema (exemplo: detecção de objetos).
Mas quanto à “melhor” técnica/biblioteca é complicado responder, pois o melhor pode ser muito subjetivo e depende do objetivo a ser atingido, por isso que é comum nos cursos mostrar pelo menos 2 abordagens diferentes. Para casos onde você realmente “precisa” escolher a melhor possível seria recomendado procurar um estudo comparativo ou você mesmo testar as técnicas em seu projeto e ver qual se ajusta melhor à resolução de seu problema. E como são inúmeros estudos de caso diferentes ao longo de todos os cursos ficaria inviável comparar todas com todas (e embora tenha momentos dentro do curso onde é feito comparações entre técnicas, o foco acaba sendo muito maior na implementação da abordagem). Mas se você precisar de um direcionamento eu recomendaria dar uma olhada nessa página, ou ainda pode enviar sua dúvida mais específica por aqui, que iremos auxiliar.
Olá Anderson!
Tente acessar agora, talvez no momento que você tentou acessar o servidor do site deles estava indisponível, porque agora eu tentei acessar e carregou normalmente aqui.
Caso ainda não consiga acessar o paper através desse link então acesse nesse aqui, que irá carregar o mesmo documento.
Olá Clarimar!
O link se encontra na aba “Materiais”, que está visível na primeira aula dessa implementação (nome da aula: “Treinamento personalizado – balões 1”).
Olá Henrique!
Caso não tenha visto o aviso que foi colocado, deixarei abaixo aqui nessa resposta. Basicamente, para evitar o problema você precisa fazer a instalação de uma versão anterior da biblioteca Pillow.
Execute o seguinte comando antes de todo o seu código:
!pip install Pillow==9.1.0
Após executar, clique no botão [Restart Runtime] que vai aparecer no output dessa célula, logo abaixo. Em seguida, pode continuar executando normalmente o restante do código.
Qualquer dúvida, confira o Colab da aula aqui.
Opa, para esse caso se há muitas possibilidades de layout diferentes eu acho que vai ser mais difícil encontrar alguma solução “pré-pronta” que abranja todas essas variações, mas se tiver sorte talvez encontre algo procurando em repositórios abertos como no github. O jeito seria construir o seu script próprio, preparado para extrair as informações dos documentos com layouts da forma que você precisa.
Encontrei essa abordagem também, talvez possa ser útil.
Uma alternativa à utilização de técnicas de pré-processamento seria usar algum detector de objetos (como o YOLO). Se treinar bem você consegue obter muita precisão, porém se o layout onde se encontra essa informação varia muito então recomendo tentar uma sugestão que deixo abaixo.
(aqui há um outro exemplo de como poderia treinar um modelo em deep learning para localizar/classificar partes de um documento.)
Ainda sobre o uso de técnicas de processamento, ao final da seção “Projeto 1” pode te dar uma intuição maior. Pegue por exemplo aquela imagem que usamos do rótulo com informações nutricionais do produto. Ali foi feita a busca a partir de um termo, onde retornou a posição dele na imagem. Digamos que você não sabe qual será o texto, nesse caso, você precisa saber qual é o padrão de onde ele vai aparecer, ou até mesmo a localização exata dele com base nos outros elementos da imagem. Para isso você pode utilizar as técnicas de processamento de imagem que mostramos nos 3 projetos finais. Por exemplo, se você sabe que a marca sempre aparece na primeira linha da tabela então primeiro você detecta os contornos na imagem (ou melhor, os retângulos) e extrai a área apenas daquele que se encontra mais ao topo (o que significa que constitui a primeira linha da tabela).
Caso a posição realmente não seja tão óbvia você pode treinar um detector de objetos próprio para detectar a região onde se encontra essas informações (caso não consiga bons resultados com as técnicas de pré-processamento), conforme comentei mais acima.
Ou seja, se você sabe exatamente qual texto está presente neste documento e você deseja saber se ele está ali (ou se tem alguma palavra que sempre acompanha essa informação marca, por exemplo, “Marca:” [x]) então poderia usar como base a técnica do Projeto 1, pois você consegue localizar a partir do filtro.
Mas se esse local puder variar muito ao longo do documento (porém mantém uma mesma estrutura visual, ou muito parecida) então talvez o melhor seja treinar um detector de objetos próprio (como o YOLO por exemplo) para localizar essas regiões.
Olá!
Caso queira fazer a leitura de CNH ou RG, o curso dará uma boa intuição inicial para isso. Em um dos projetos é mostrado como fazer o scan de documentos, o que funciona para o caso desse tipo de documento também. Como adicional, você precisará incorporar outras técnicas de pré-processamento de imagem para que possa extrair o textos nas regiões específicas nesse documento. Dê uma olhada nesse artigo que mostra exatamente como você poderia fazer isso (e tem o código inclusive) -> https://medium.com/stackchain/drivers-license-ocr-cnh-with-python-opencv-and-tesseract-21b0388ae101
