Respostas no Fórum
- Posts
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!
Olá Douglas!
Para definir esse valor foi usado a mesma fórmula vista na aula “Construção e treinamento da rede neural”.
Primeiramente você deve obter a descrição de todas as camadas usando o .summary(). Você precisa pegar os valores de dimensões da última camada de max pooling.
Em seguida é necessário “achatar” (flatten), fazendo a transformação de matriz em vetor.
Esses valores que serão usadas na camada de entrada da rede neural.
Fórmula: (número de entradas da rede neural + número de classes) / 2
Ou seja, para esse exemplo a entrada é (14, 14, 32) então vai ficar: 14 * 14 * 32 = 6272
(6272 + 2) / 2 = 3137Tudo isso é explicado com mais detalhes nessa aula, portanto sugiro ver ela inteira pois lá é explicado bem certo.
Olá Douglas!
A escolha do número de camadas vai depender de vários fatores, como a complexidade do problema, a quantidade de dados disponíveis e os recursos computacionais que possui na máquina onde será executado. Portanto, em projetos reais não há uma regra fixa, e a arquitetura da rede geralmente é definida após analisar outros trabalhos semelhantes publicados com o mesmo objetivo ou por meio de experimentação, testes e ajustes.
A ideia é começar com uma arquitetura básica e ir aumentando a complexidade conforme necessário. Em tarefas simples, redes com menos camadas podem ser suficientes, enquanto em problemas mais complexos (como reconhecimento facial ou classificação de objetos em grande escala), redes mais profundas são necessárias para capturar as características mais sutis das imagens. Isso caso deseje criar sua própria rede, pois lembrando que existem implementações que auxiliam no desenvolvimento, evitando a necessidade de se definir e escolher manualmente os critérios da arquitetura como a quantidade de camadas.
O que se faz durante o desenvolvimento é monitorar o desempenho da rede (usando métricas como precisão, recall e loss) e ajustar a quantidade de camadas e neurônios conforme necessário. Também é comum utilizar técnicas como validação cruzada para evitar overfitting e garantir que a rede generalize bem para novos dados.
Ou seja, a quantidade de camadas e a arquitetura da rede vão depender muito do seu objetivo e da complexidade do problema que você está tentando resolver. Se você deseja ajustar manualmente a arquitetura e criar sua própria implementação, recomendo seguir para cursos mais avançados na Trilha de Visão Computacional ou de Deep Learning, onde você pode explorar técnicas e práticas mais sofisticadas. Este curso em particular tem um objetivo mais introdutório e visa fornecer uma base sólida. Em cursos mais avançados de Deep Learning (por exemplo o Deep Learning com Python de A à Z), você terá a oportunidade de desenvolver uma intuição mais apurada para ajustar redes neurais de acordo com diferentes tipos de problemas da área, o que será útil caso tenha a intenção de desenvolver sua própria solução.
Olá João!
Para dividir uma imagem maior em várias subimagens você pode usar dois loops para cortar a imagem em blocos de 640 x 640 pixels.
A ideia é basicamente iterar sobre as coordenadas da imagem original e através dessas coodenadas xy você delimita o inicio/fim de cada pedaço da imagem, de forma que a cada iteração uma subimagem seja extraída e armazenada.
Aqui está um exemplo de código:
# Carrega a imagem imagem = cv2.imread('sua_imagem.jpg') # (Tamanho das subimagens) altura_subimagem = 640 largura_subimagem = 640 # Obter as dimensões da imagem original altura, largura, _ = imagem.shape # Loop para cortar as subimagens for i in range(0, altura, altura_subimagem): for j in range(0, largura, largura_subimagem): # Coordenadas para cortar subimagem = imagem[i:i+altura_subimagem, j:j+largura_subimagem] # Salvar ou processar a subimagem nome_arquivo = f'subimagem_{i}_{j}.jpg' cv2.imwrite(nome_arquivo, subimagem)O loop corta a imagem em subimagens e cada subimagem é salva como um arquivo separado. Você pode ajustar o nome dos arquivos conforme necessário. Com isso, sua imagem original de 3.000 x 4.000 pixels será fragmentada em várias imagens menores, todas do tamanho que você especificou (640 x 640 pixels).
Opa, que ótimo que melhorou bastante o desempenho!
Comparando esses dois testes, dá para comprovar que ambas as abordagens têm suas vantagens e desvantagens. Usar base64 resulta em um arquivo significativamente menor (710 KB contra 9.002 KB com pickle), o que é vantajoso para armazenamento e transmissão de dados. No entanto, a performance de pickle é superior tanto no tempo de cadastro quanto carregamento e processamento.
Portanto, a escolha entre as duas depende das suas prioridades. Se o objetivo principal for economizar espaço de armazenamento e garantir portabilidade, base64 é a melhor opção. Por outro lado, se a prioridade for performance e rapidez na leitura e escrita de dados, pickle é mais recomendado. Avalie o que é mais importante para seu projeto e escolha a abordagem que melhor se alinha às suas necessidades. Caso escolha a pickle devido à velocidade, você pode ainda tentar aplicar técnicas para reduzir o tamanho em disco, como explicado nesse artigo por exemplo.
Olá Cesar!
Para melhorar a performance ao armazenar e exibir imagens coloridas em um DataFrame eu acredito que algumas mudanças podem ser feitas na sua abordagem.
No código de cadastro de usuários no DataFrame, atualmente você está convertendo cada imagem em uma lista antes de armazenar, o que pode ser bem ineficiente em termos de espaço e tempo de execução. Além disso, ao ler as imagens do DataFrame, você está usando ast.literal_eval para converter as strings de volta em listas, o que também pode vir a ser extremamente lento.
Uma abordagem mais eficiente seria armazenar as imagens codificadas em base64 diretamente no dataframe. Isso não só melhora a performance, mas também facilita a manipulação dos dados.
E codificando as imagens em base64 você reduz o tempo necessário para converter entre diferentes formatos de dados. Armazenar imagens codificadas como strings base64 em um CSV pode ser mais eficiente do que armazenar listas de números, além de facilitar a manipulação dos dados. Isso deve resolver o problema de performance que você está enfrentando e tornar o processo de armazenamento e recuperação de imagens mais eficiente.
Aqui está uma sugestão de código com base no que você informou:
[ ... importações e restante do código ] # Função para converter imagem para base64 def image_to_base64(image): _, buffer = cv2.imencode('.jpg', image) image_base64 = base64.b64encode(buffer).decode('utf-8') return image_base64 # Função para converter base64 para imagem def base64_to_image(image_base64): image_data = base64.b64decode(image_base64) image_np = np.frombuffer(image_data, dtype=np.uint8) image = cv2.imdecode(image_np, cv2.IMREAD_COLOR) return image # Cadastrar usuario no Dataframe def cadastra_dataframe(full_name, imagem): nome = [full_name] imagem_base64 = [image_to_base64(imagem)] # Abrindo df existente df = pd.read_csv('usuario.csv') # Dados para ser incluído o dataframe existente dados = {'full_name': nome, 'imagem': imagem_base64} dados = pd.DataFrame(dados) df = pd.concat([df, dados], ignore_index=True) df.to_csv('usuario.csv', index=False) # Exibir as imagens gravadas no dataframe dados_df = pd.read_csv('usuario.csv') ### E para iterar sobre cada linha do DataFrame para exibir as imagens for i in range(len(dados_df)): full_name = dados_df['full_name'][i] print(full_name) inicio = time.time() imagem_base64 = dados_df['imagem'][i] imagem_array = base64_to_image(imagem_base64) fim = time.time() execucao = fim - inicio print(f'tempo de execucao : {execucao:.6f} segundos') cv2.imshow('Imagem Recuperada', imagem_array) cv2.waitKey(0) cv2.destroyAllWindows()Olá Douglas!
Com o conhecimento do curso de Reconhecimento e Detecção Facial com Python você conseguirá criar sim a sua solução de reconhecimento facial. E seguir o restante da trilha é também recomendado para obter uma maior intuição e aprender a dominar melhor as principais bibliotecas de visão computacional, como OpenCV e Dlib (e assim saber o caminho adequado para desenvolver sua própria solução).
Embora não tenha atualmente um curso na trilha com a proposta específica de desenvolver um sistema próprio e completo com esse objetivo, você terá todo o conhecimento sobre a IA necessária para a tarefa de reconhecimento e saberá como fazer o treinamento da mesma, para que ela aprenda a reconhecer qualquer rosto. Portanto, o curso citado não mostra como criar passo a passo tal aplicação, pois isso foge do propósito (nesse caso procurar por cursos de desenvolvimento de sistemas, ou desenvolvimento de interfaces por exemplo, como é possível encontrar aqui na plataforma também).
Apesar de ensinar a usar técnicas modernas e robustas, o uso dessas técnicas de reconhecimento facial em sistemas de CFTV podem ser um pouco mais desafiadoras devido a fatores como qualidade de câmera, ângulo, etc – portanto, requer uma atenção maior a certos detalhes. Mas qualquer dúvida que tiver sobre o conteúdo ou dicas adicionais você pode perguntar aqui no fórum.
Olá Vinicius!
O que resolve esse erro geralmente é interromper o Kernel, reiniciar o ambiente de execução (na página inicial do painel do SageMaker) e abrir novamente ao ambiente com GPU.
Se persistir, peço que compartilhe aqui um print das últimas informações que aparecem na saída da célula onde há o comando para abrir a interface (etapa 4), se possível um print ou pode copiar e colar se preferir, mostrando as últimas informações que foram exibidas antes de aparecer esse problema. Talvez com essas informações adicionais eu consiga verificar melhor o que poderia estar causando e assim determinar como resolver.
Olá Victor!
Para passar para a rede neural as imagens são geralmente convertidas para vetores (um array unidimensional), pois essas camadas trabalham com dados em formato vetorial. Por isso que anteriormente você viu ser feito dessa forma.
No entanto, para visualização e algumas operações específicas é mais conveniente e necessário trabalhar com imagens no formato matricial (bidimensional). No código que você mencionou, o X_teste[0].reshape(28,28) está convertendo o vetor de volta para uma matriz de 28×28 pixels para que possamos visualizar a imagem original de maneira mais intuitiva. Ou seja, é apenas para visualizarmos a imagem (repare que para isso estamos usando a função plt.imshow, que é justamente usada para exibir a imagem).
Portanto, essa conversão não é necessária para o processamento na rede neural, mas é útil para a visualização e interpretação dos dados. Então, embora a imagem seja processada internamente como um vetor ao passar pelas camadas densas, ela é reformatada em uma matriz para facilitar a visualização.
Olá Cesar!
Nesse caso você vai precisar instalar antes o CMake, disponível para baixar aqui https://cmake.org/download/
Em seguida, instale também o compilador Visual studio tools: https://visualstudio.microsoft.com/visual-cpp-build-tools/. Durante a instalação, certifique-se de selecionar os componentes de desenvolvimento de C++.
Para evitar alguns erros comuns que podem vir a ocorrer, eu sugiro dar uma olhada nesse artigo, que contém algumas dicas de como evitar os erros, como por exemplo adicionar o CMake às variáveis de ambiente do Windows.
Olá Victor!
Para fazer uma cópia do arquivo da aula no Colab, selecione a opção “Arquivo > Fazer uma cópia no Drive”, no menu do topo.
Caso tenha dúvidas, veja a aula “Carregamento e processamento da imagem”, isso é mostrado no minuto 1:33 do vídeo.Como alternativa você pode fazer o download do .ipynb dentro da mesma opção Arquivo e depois fazer o upload no Colab, mas desse modo acima acaba sendo mais prático.
O link para o Colab contendo o código está presente sempre na primeira aula da seção, ou da primeira aula onde aquele código é exibido. E quanto aos demais arquivos que serão usados ao longo do curso, estão no drive da aula “Recursos para download”.
Olá!
Na verdade está um pouco invertido de acordo com a ordem que você apresentou. O correto seria:
- Verdadeiro Positivo = 129
- Falso Positivo = 60 (pois a predição foi ‘isoladores’ e o real era ‘fundo’, portanto é incorretamente marcado como positivo)
- Falso Negativo = 89 (pois a predição foi ‘fundo’ mas na realidade era ‘isoladores’, portanto é incorretamente marcado como negativo)
- Verdadeiro Negativo = (não aplicável)
Portanto, talvez assim estaria mais próxima da ordem que você mencionou estar mais acostumado, embora não exatamente ainda. Aliás, acredito que não deve haver uma forma “correta”, se for pesquisar verá que não há uma unanimidade nesse sentido pois pode-se encontrar diversos materiais e artigos sérios onde tanto o FP quanto o FN estão em cima, ou outros onde segue essa mesma ordem que você passou. No entanto, possivelmente a ordem mais usada é onde o Verdadeiro Positivo esteja no canto superior esquerdo e o Verdadeiro Negativo esteja no canto inferior direito (aliás, se pesquisar em inglês observará que é mais comum ainda seguirem essa mesma ordem que o YOLO usa).
Olá Brenda!
Para saber qual a época que corresponde ao melhor modelo treinado (o best.pt) você pode consultar o arquivo results.csv que é executado durante o treinamento. Este arquivo registra métricas como precisão, recall, mAP e perda de valor para cada época. Procure a época com melhor desempenho (geralmente a menor perda de validação ou o maior mAP, dependendo de qual best.pt foi selecionado) para identificar a época a que corresponde o seu modelo best.pt. Lembrando que esse arquivo best.pt (contendo os pesos salvos para o melhor resultado) também está acessível dentro do diretório de treinamento, junto ao last.pt (os pesos mais recentes salvos, independente de serem os melhores ou não).
