Forum Replies Created
- Posts
Olá Everton!
É possível sim, para fazer essa alteração basta usar a implementação via Python (não pela CLI, já que não tem liberdade para fazer esse tipo de alteração a não ser que mude o código da própria biblioteca), a função que precisa modificar é desenha_caixas() dentro de funcoes_desenho.py (que disponibilizamos para fazer esse tipo de implementação). Na linha onde tem o “colors = “, repare que para essa variável é atribuída uma lista com vários valores RGB. Nessa lista os valores de cores serão atribuídos de forma fixa, e conforme a ordem dos itens cadastrados na variável labels, que está logo acima nesse mesmo código. Ou seja, o valor (89, 161, 197) corresponde à primeira classe listada em labels, já o valor (67, 161, 255) corresponde à segunda, e assim consecutivamente.
Mas para fazer com que seja atribuída uma cor diferente para cada instância (e não mais usar a classe como critério para diferenciação de cor) precisa mudar a lógica, para isso não vai mais usar essa lista com valores fixos, agora fará com que seja gerada uma cor aleatória para cada segmento detectado. A linha que deverá ser mudada é a dentro da condição “if conf :” (que controla se a segmentação possui confiança o suficiente para ser exibida), lá na linha “color = colors[int(box[-1])]”; o que precisa é mudar isso para que o valor de color seja um valor aleatório.
Você pode usar esse código para gerar uma cor aleatória: color = np.random.randint(0, 255, size=(1, 3), dtype=”uint8″)
Como deve ser feito para cada instância, deve colocar esse código dentro do laço de repetição “for box in boxes:”. Ou, pode gerar antes desse laço uma lista com os valores aleatórios, de modo que o tamanho da lista seja baseada na quantidade de instâncias detectadas na imagem, usando o len(boxes) para indicar a quantidade de cores aleatórias a serem geradas. Assim:
lista_cores = np.random.randint(0, 255, size=(len(boxes), 3), dtype=”uint8″)
E aí só acessar a cor através dos colchetes, especificando a posição com base na iteração atual.
Já para separar a segmentação do fundo e salvar em uma imagem, veja a aula “Modelo pré-treinado 6” do curso “Segmentação de Imagens com Python de A à Z”, lá mostra como você pode fazer isso. E para salvar a imagem em disco basta usar a função cv2.imwrite(), que foi mostrada anteriormente mas você pode ver mais detalhes sobre ela aqui. Lembrando de nomear a imagem de modo que fique com nome diferente sempre, tipo assim (ou gerando um nome aleatório único, como nesse exemplo aqui).
Olá Pedro!
Estive analisando o seu caso, primeiramente vou passar algumas dicas referentes a como você pode imediatamente melhorar. Mais pro final, vou explicar resumidamente duas ideias que eu pensei e que eu pelo menos faria nessa situação; a primeira dará mais garantia na precisão da detecção (mantendo a qualidade da segmentação) da classe e assim evitar falsos-positivos, que é o que acontece no caso do tomate que é segmentado/detectado como carne; a outra seria em relação à questão da gordura, que você comentou.
Quanto às dicas:
- A primeira sugestão continua sendo a da minha resposta anterior. Adicionar mais dados de treinamento vai ajudar o modelo a aprender características mais discriminativas e generalizar melhor para diferentes objetos e cenários. Mas além de apenas aumentar a quantidade de imagens, certifique-se de incluir uma variedade de exemplos de diferentes objetos, ângulos de visão, tamanhos e fundos. Isso ajuda o modelo a capturar a variação na aparência dos objetos da classe que você está segmentando, assim ele vai generalizar melhor e se for bem treinado isso indica também que aprenderá a diferenciar melhor. Obs: se estiver complicado conseguir novas amostras, pode utilizar técnicas de data augmentation.
- Em seguida, após adicionar mais imagens treine por mais tempo. Não tem um limite, mas recomendo fazer testes comparativos com os modelos mais recentes treinados, para evitar que não pegue um modelo que passou pelo overfitting.
- Se possível, certifique-se de que as anotações das instâncias estejam corretas e alinhadas com as imagens. Erros ou imprecisões nas anotações podem levar a resultados incorretos. Eu acredito que o seu dataset esteja, mas as vezes nunca é demais certificar isso já que tem total impacto.
- Teste com diferentes hiperparâmetros, que podem ser definidos na função ConfigRede(). Experimente ajustar esses parâmetros para obter melhores resultados. No geral esses que foram passados já são o suficiente, mas como cada dataset é um caso, é aconselhável testar com outros. Dê uma olhada nesse artigo aqui que pode lhe apresentar algumas ideias.
- Em último caso, se tiver tempo considere explorar diferentes arquiteturas de rede neural, como variantes do Mask R-CNN ou outras redes de segmentação de instâncias, que podem se adequar melhor ao seu problema. Exemplo: YOLACT.
Agora as ideias que eu havia mencionado, eu pelo menos faria assim caso não conseguisse resultado bons com as dicas acima (ou testaria mesmo se conseguisse bons resultados, para comparar as abordagens)
- A ideia é usar algum algoritmo de detecção de objetos para a detecção, como o YOLOv8, que é mais recente e bastante preciso. Eu treinaria com ele para garantir uma melhor detecção do objeto, pois lembre aqui que você tem um problema grande por exemplo com os tomates que são classificados como carne, isso pode ser complicado de eliminar totalmente com soluções de segmentação de instâncias já que no geral elas podem não ser tão precisas quanto um detector de objetos seria (na verdade elas podem ser quase tão precisas quanto, mas precisa ser bem treinada antes, o que leva tempo).
- Então, a lógica seria usar o YOLOv8 para garantir uma detecção precisa da classe (e assim ignorar melhor outros objetos parecido com carne mas que não sejam) e então depois de detectado o objeto você pode aplicar na região de interesse (a área dentro da caixa delimitadora) uma solução para segmentação genérica, como o SAM (Segment Anything Model). Ele funciona bem para a grande maioria das coisas, pode ser que retorne uma máscara bem mais precisa até que o Mask R-CNN (repare que tem muitas falhas, e isso é normal até para um modelo bem treinado).
- Caso tenha dúvidas de como fazer isso na prática, veja esse artigo que já mostra como usar os dois em conjunto.
- A outra ideia que pensei seria referente ao problema de segmentação de gorduras que você mencionou nessa outra resposta. Se a sua ideia é saber a porcentagem de gordura então é ideal segmentar essa gordura usando as técnicas classicas de segmentação, que são apresentadas na primeira seção. Acredito que alguma delas vá funcionar muito melhor que usar Mask R-CNN para segmentar as gorduras (e sem falar que exigirá muito menos esforço, já que não precisa treinar um modelo).
- Pode ser segmentação por cores ou a limiarização por exemplo, veja um exemplo parecido aqui. Claro que nem toda a área branca ali da carne será a gordura, mas você pode fazer testes e ajustar, encontrar um método de limiarização que faça bem a separação entre a carne e gordura.
- É aconselhável esses tipos de técnicas pois a gordura não possui um formato tão específico, e muitas vezes ela pode aparecer ali com um formato bem fino. Por isso que caso esteja com dificuldade de fazer isso com o Mask R-CNN pode partir para essas outras técnicas.
Olá Anthony!
Tem como sim, você pode digitar termos como “vector graphic, black white, line art” ao final do seu prompt, e depois ir ajustando para ficar de acordo com o resultado desejado. Depois você pode buscar por uma ferramenta (online ou programa) para transformar a imagem jpg em vetor, como o https://www.vectorizer.io.
Para gerar SVG e vetores com o Stable Diffusion eu recomendo você dar uma olhada no VectorStudio: https://github.com/GeorgLegato/stable-diffusion-webui-vectorstudio – Nesse repositório tem as ferramentas e comandos necessários para gerar bons resultados, assim economizando tempo.
Ou, como alternativa, se quiser pode buscar por outra abordagem para geração de vetor SVG a partir de prompt de texto como o VectorFusion, que também é baseada em Stable Diffusion.
Olá Pedro!
Primeiramente, ficamos felizes que esteja gostando do conteúdo do curso!
Sobre sua dúvida, isso pode ser meio comum ocorrer mesmo, ainda mais quando há semelhanças discutíveis entre os objetos de interesse e os identificados de forma incorreta. Mas tem algumas sugestões que podemos testar para resolver.
Qual o tamanho do seu conjunto de treinamento e o de validação? E por quantas épocas você treinou? E quais parâmetros para treinamento você deixou na hora de configurar a rede?
A primeira sugestão e a mais relevante seria treinar por mais tempo ou ampliar seu dataset e retreinar (ou continuar treinamento), mas antes acho que seria melhor saber essas dúvidas.
Olá! Para construir seu próprio haar cascade com o objeto que deseja detectar você pode seguir os passos explicados no curso Detecção de Objetos com Python & OpenCV aqui na plataforma, pois o processo de treinamento demanda muito mais detalhes então foi necessário um curso específico sobre essa abordagem.
Olá Artur!
Isso ocorre porque provavelmente em uma versão recente da biblioteca houve uma alteração pequena no algoritmo mas que foi o suficiente para influenciar no reconhecimento de algumas imagens mais “desafiadoras” (como essa, de um cenário natural). Para identificar agora a palavra BEGIN com essa imagem precisa mudar o parâmetro, deixando “psm 11” por exemplo consegue fazer o OCR do texto na caneca dessa imagem. O código fica assim então:
config_tesseract = "--tessdata-dir tessdata --psm 11" resultado = pytesseract.image_to_data(rgb, config=config_tesseract, lang="por", output_type=Output.DICT)
Nas aulas das próximas sessões verá formas melhores de reconhecer textos em cenários naturais, então nem se preocupe muito agora em ficar escolhendo o melhor parâmetro para pegar o texto usando o Tesseract. Há métodos mais eficazes nessas situações (como por exemplo, fazer a detecção do texto antes do OCR, ou usar outro algoritmo como o EasyOCR que já oferece a localização de texto embutida no comando), e lá nessas aulas vai ser explicado o porquê são melhores nesses casos.
Olá Paulo!
Consegue rodar em sua máquina local sim, você pode usar o mesmo código, só lembre que precisa ter uma GPU em funcionamento. Atualmente, a implementação do Stable Diffusion possui mais suporte para GPUs da Nvidia, porém se a sua for da AMD então recomendo seguir esses passos adicionais para conseguir rodar.
Olá Julio!
Sim, a informação é acessível agora pelo resultado.mask.data, porém a API mudou recentemente e com isso tem que utilizar um outro algoritmo para poder desenhar as máscaras manualmente. Como ainda não temos esse código pronto, sugiro que para a segmentação utilize a implementação via CLI, pois irá funcionar corretamente e de modo mais prático.
Olá Daniel! Que bom que já encontrou =) é ali mesmo, os Colabs se encontram no início da sessão (na verdade, na primeira aula onde o conteúdo a ser implementado é apresentado).
Olá Rodrigo, eu verifiquei aqui seu código e encontrei o motivo. O problema está na função mostra_reconhecimento(), na primeira linha (onde é declarado os parâmetros da função). Em seu código é definido a variável lista_nome, porém na linha seguinte é passado para a função reconhece_faces() a variável lista_nomes, com “s”, e o valor que você passou à função mostra_reconhecimento é lista_nome, sem o “s”. Na verdade então ele está passando ao reconhece_faces() a lista de nomes do seu exemplo anterior, cuja variável possui esse exato nome (e que contém 9 valores), e não a lista de nomes do dataset_celeb (que contém 55 valores); então por isso dá erro pois assim pode ocorrer de acessar um índice que não existe na lista, já que está passando a lista errada e com apenas 9 valores.
Portanto, para resolver basta corrigir em sua função o lista_nome, deixando lista_nomes.
def mostra_reconhecimento(imagem_teste, lista_encodings, lista_nomes, max_width = 700, tolerancia = 0.6): localizacoes, nomes, confiancas = reconhece_faces(imagem_teste, lista_encodings, lista_nomes, tolerancia) for face_lock, nome, conf in zip(localizacoes, nomes, confianca): y1, x2, y2, x1 = face_lock [0], face_lock[1], face_lock[2], face_lock[3] cv2.putText(imagem_teste, nome, (x1, y1 -10), cv2.FONT_HERSHEY_DUPLEX, 0.8, (0,0,255), 2) cv2.rectangle(imagem_teste, (x1, y1), (x2, y2), (0, 10,255), 4) print(conf) if imagem_teste.shape[1] > max_width: imagem_teste = imutils.resize(imagem_teste, width = max_width) cv2_imshow(imagem_teste)(ou, também para resolver poderia passar para a função reconhece_faces o lista_nome sem “s”, já que é esse valor que foi recebido como parâmetro).
Olá Rodrigo!
Esse erro geralmente ocorre quando há um problema ao ler a imagem, pode acontecer quando o caminho/nome (passado como parâmetro na função que faz a leitura da imagem) está incorreto, ou ainda a imagem pode estar corrompida de algum modo. Mas o Colab dizer que é por causa do “0” é estranho, se quiser que eu ajude a entender o motivo me passe qual aviso que o Colab mostrou para você pedindo para ajustar esse nome.
Mas que bom que já conseguiu resolver!
Olá Rodrigo!
Esse erro ocorre geralmente quando tentamos acessar um item de uma lista usando um índice que não existe na lista.
Verifique se o list_names (que você passou como parâmetro à função do mostra_reconhecimento) está contendo os valores esperados, pode ser dando um print() na variável mesmo.
Desse trecho de código que você mostrou na imagem parece estar correto, mas sugiro comparar com o restante do código do colab da aula (aqui). Se mesmo assim não descobrir o erro, peço que se possível compartilhe o seu Colab aqui para eu conseguir verificar melhor pois deve haver outra coisa no código interferindo e causando isso.
Opa, nesse caso é um problema em relação ao limite de memória disponível mesmo. Para isso tem algumas coisas que podemos fazer. O que influencia um pouco também é o fato do Mask R-CNN atualmente não ser tão otimizado paras as versões mais recentes do Tensorflow (e não podemos mais fazer o downgrade para a versão 1.x pelo Colab infelizmente, para fazer isso teria que instalar localmente).
Mas enfim, para otimizar o uso da memória você pode tentar algumas coisas, que funcionou para os outros alunos que recomendamos:
Primeiro seria reduzir o tamanho das imagens do dataset, que estariam grandes para processar. Você pode tentar diminuir o tamanho das imagens, até porque na verdade ele não precisa ser tão grande assim. O tamanho é controlado pelos seguintes parâmetros IMAGE_MIN_DIM e IMAGE_MAX_DIM.
Os valores padrões são 800 e 1024, respectivamente, então podemos reduzir já que não há a necessidade de um tamanho tão grande, ainda mais para um dataset cujo objeto possui um formato onde não há detalhes tão pequenos. Então, podemos tranquilamente abaixar para 512 por exemplo, desse modo conseguimos executar no Colab sem erros.
Já aproveitando, sugiro também mudar o valor do VALIDATION_STEPS para = 5, já que devido ao número de passos definido ele não precisa ser tão grande também.
Mas apenas com essa alteração já consegui rodar aqui usando o mesmo Colab, se quiser confira aqui e compare com seu código.
Uma segunda opção para otimizar o uso da memória seria mudar a rede de backbone, que por padrão é a resnet101 porém você pode mudar para a resnet50 e assim reduzir o uso da memória, além de treinar mais rápido.
Mas isso só precisa fazer caso mesmo com a mudança no tamanho ele ainda ultrapasse o limite de memória.
Você pode testar aquela alteração antes, e se ocorrer o erro, faz essa outra mudança também. Porém apenas mudando o tamanho já é para funcionar com esse dataset dos balões pelo menos, e mais outros que testamos. Se for um dataset muito mais complexo então pode ser que realmente precise de mais essas outras configurações adicionais para conseguir rodar no Colab.
Obs: Esses parâmetros você define lá na classe ConfigRede.
Veja que lá já tem alguns parâmetros definidos, como o IMAGES_PER_GPU = 2
para definir esses outros basta colocar ele dentro da classe, entre o “class ConfigRede(Config):” e o “config = ConfigRede()”. É igual ao padrão que estão nos outros ([Parâmetro] = [Valor]), por exemplo assim:
IMAGE_MIN_DIM = 512
IMAGE_MAX_DIM = 512
