Respostas no Fórum
- Posts
Olá, dei uma analisada aqui.
Primeiramente, você pode mudar ali de: mask[rr, cc, i] = 3
para: mask[rr, cc, i] = 1
O certo seria atribuir o valor 1 ao invés de 3, caso você continue trabalhando com máscaras binárias (pois os valores só podem ser 1 ou 0)
Porém pela mensagem de erro, parece que esse problema em questão ocorre porque durante o treinamento a máscara não pôde ser carregada, o que faz ele emitir essa mensagem. Isso provavelmente ocorre porque algum ponto do polígono usado para anotação ficou fora da imagem.
Ou seja, o ponto marcado na anotação está “fora” dos limites (largura e altura máximo) da imagem, tem alguma ponto/coordenada cujo valor excede o limite máximo do eixo x (largura) ou y (altura). Isso pode ter sido devido a um bug da ferramenta de anotação, onde provavelmente para essa imagem que ocorreu o problema o objeto se encontrava bem encostado na borda da imagem, então quando foi fazer a anotação acabou pegando no limite e o programa considerou como um ponto válido embora esteja tecnicamente fora do limite da imagem, pois como pegou bem na borda alguma parte ficou “fora” da imagem, 1 pixel fora já o suficiente para ocorrer isso (e o programa não faz uma checagem posterior para certificar que o ponto não ficou fora da imagem, ele apenas gera os pontos).Então a solução mais óbvia seria percorrer manualmente por cada amostra do dataset e ver em qual delas a máscara se encontra fora dos limites da imagem, e fazer a correção da anotação. Pela mensagem de erro (index 781 is out of bounds for axis 1 with size 781), você poderia filtrar pelas imagens de 781 px de largura ou altura e checar elas, pois sabe que é esse o tamanho limite da imagem com problema.
Porém, percorrer imagem por imagem do dataset e corrigir manualmente pode ser trabalhoso, por isso o que pode te ajudar seria programar direto em seu código para que caso o ponto da máscara exceda esse limite do tamanho da imagem então ele coloque como sendo um ponto dentro da imagem, usando a largura/altura máxima ou minima para saber onde deve colocar o ponto. Ao invés de codificar isso sozinha, encontrei um código que vai te facilitar bastante o trabalho: https://github.com/matterport/Mask_RCNN/issues/636#issuecomment-447751080
É um código que não testamos mas pelo que vimos parece funcionar, e talvez você precise fazer algum ou outro ajuste para que se adeque à sua função (mas a princípio ele deve funcionar para outra forma de anotação além dos polígonos, como é o seu caso).Olá Carla, quando puder mude a permissão do Colab (lá no botão Compartilhar, no canto superior direito) para que fique acessível pelo link, pois assim consigo visualizar por aqui.
Olá Carlos!
Para o caso de detecção de imagens e reconhecimento facial não temos um curso que aborde a implementação de um projeto real que use banco de dados, já que o foco se concentrou mais na implementação e exploração das abordagens em si.
Mas se deseja usar banco de dados em seu projeto, recomendo que dê uma olhada nesse vídeo aqui: https://www.youtube.com/watch?v=6gWS2CdtZrs
Ele explica bem como você pode usar seu projeto com um banco de dados.
Também sugiro ver esse material aqui, onde ele usa SQLite.
Se prefere MySQL por exemplo, também tem esse outro exemplo aqui que será bastante útil.
Olá, fizemos a atualização do código no Colab oficial do curso, dê uma olhada: https://colab.research.google.com/drive/1CEu9aKbtM0jDZMUN2282fMwV4c-fEn5O
Lá já se encontra a linha de código necessária para deixar compatível com essas versões mais recentes do Tensorflow.
Dentro da próxima semana provavelmente colocaremos uma aula de aviso, explicando mais sobre essa mudança.
Portanto, por enquanto se baseie no código do link acima, caso encontre algum problema para executar nos avise por favor (e se possível compartilhe o seu Colab, para verificarmos por aqui).
Olá Carla!
Se você fez a anotação com o VIA (ou outra ferramenta que retorne as anotações para essas formas no formato .json) então você pode fazer a adaptação da forma sugerida. Ou seja, ao invés de
rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'], mask.shape)
vai ficar assim
if p['name'] == 'polygon': rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'], mask.shape) elif p['name'] == 'circle': rr, cc = skimage.draw.circle(p['cx'], p['cy'], p['r']) else: rr, cc = skimage.draw.ellipse(p['cx'], p['cy'], p['rx'], p['ry'], rotation=np.deg2rad(p['theta']))
(isso dentro do laço de repetição for i, p in enumerate(info[“polygons”]))
Caso não funcione, peço que compartilhe aqui a mensagem de erro exata que aparece para você, assim conseguimos te auxiliar melhor.
Olá Carla!
Isso parece estar associado à mudança recente no Colab nessas 2 ultimas semanas, onde ele passou a atribuir às novas sessões uma versão do Python onde o pip não consegue baixar uma versão inferior à 2.x., que é necessário para o repositório oficial do Mask R-CNN.
Estamos analisando se há uma maneira de solucionar isso executando algumas poucas linhas de comando e assim conseguir usar a mesma versão do tensorflow, mas caso não funcione faremos uma aula contendo as mudanças de código necessárias para poder implementar a segmentação com o tensorflow 2.
Por enquanto, para rodar no Colab a segmentação com o Mask R-CNN você pode usar esse repositório auxiliar, no lugar do repositório que usamos (o github.com/matterport/Mask_RCNN), ele foi desenvolvido para ser compatível com essas novas versões. Ou, se preferir você pode seguir os passos desse artigo aqui, que explica como fazer tanto o treinamento quanto a inferência.
Olá Getulio!
Verifique se lá na variável class_names (que você alterou para colocar as classes do seu modelo) está assim:
class_names = [‘BG’, ‘Lata’, ‘Cigarro’]
Se estiver, então faça um teste: coloque print(r[‘class_ids’]) logo abaixo de r = resultados[0], dentro da função processa_frame (nessa parte aqui). E veja os IDs que aparecem para você após testar em uma foto onde há lata e cigarro. Tem que aparecer o ID da classe ‘lata’ e da classe ‘cigarro’, se aparecer o mesmo ID para todas as segmentações na imagem então pode ter acontecido algum problema ao definir as configurações de treinamento. No caso, você precisa certificar que lá dentro da função load_object o código fica por exemplo assim
self.add_class(“objetos”, 1, “lata”)
self.add_class(“objetos”, 2, “cigarro”)
certificando que sejam passados IDs distintos, para cada classe, no caso, 1 e 2.
Olá Jardel!
Não precisa inicialmente estar em escala de cinza, mas depois convertemos para esse espaço de cor porque as funções de reconhecimento e detecção esperam uma imagem em escala de cinza, já que os algoritmos abordados no curso trabalham com imagens assim.
Se não converter antes ele vai converter dentro da função de reconhecimento. Ou seja, se você usar mais de um método que trabalhe com imagem em tons de cinza ele vai fazer a conversão mais de uma vez. Por isso que, por motivos de performance, se faz a conversão antes de passar como parâmetro (embora seja uma melhora praticamente imperceptível para nós). Pois lembrando, a imagem em escala de cinza possui menos dados e o processamento tende a demorar bem menos.
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.
