Respostas no Fórum
- Posts
Olá David!
Essa mensagem realmente aparece no output da célula, mas na verdade esse aviso não deveria influenciar o funcionamento do restante do código, portanto deveria estar dando para executar o código normalmente. Se não estiver rodando para você, poderia compartilhar aqui o seu Colab? Assim eu posso analisar melhor o que pode estar acontecendo e se há outra coisa interferindo, pois hoje fiz mais um teste com o mesmo código e rodou normalmente.
Olá Wellington!
O denoise é implementado por padrão pelo método usado para criar a pipeline, então você pode fornecer esse parâmetro junto com os demais (prompt, prompt negativo, cfg, etc.). Para saber como usar, veja a aula “Parâmetros – inference step” (“inference step” nesse contexto é o mesmo que “denoising step”).
Quanto ao Karras sigmas, parece que já possui suporte no diffusers para todos os schedulers mais populares. Para implementar, você tem que passar o parâmetro assim: “use_karras_sigmas=True”.
Já o Refiner também é possível, porém ele é usado mais no contexto do SDXL (Stable Diffusion XL), mais detalhes.
Olá Rogério,
As imagens usadas no curso estão na pasta do Drive compartilhada na aula “Recursos para download”.
Esse link: https://drive.google.com/drive/folders/1jcWIoIWlFJ2ocERjW0p2W1cZ4LRMEjM5?usp=sharing
Para as aulas do YOLOv8, as imagens estão na pasta “Atualização YOLOv8 > fotos_teste”.
Caso não tenha encontrado alguma imagem, por gentileza informe qual para podermos lhe auxiliar.
Olá Wellington!
Quando são geradas múltiplas imagens de uma única vez, o resultado da função pipe (ou outro nome que você definiu) é uma lista, então para acessar uma imagem específica basta acessar através do índice. Por exemplo, para acessar a primeira foto da lista você pode simplesmente colocar em uma célula assim: imgs[0] (supondo que imgs é o nome que escolheu para a variável que recebe o resultado da geração). Portanto, para a segunda imagem é imgs[1].
Abaixo deixo um exemplo de código que salva a segunda imagem da lista em uma variável, e depois você pode fazer o que quiser e como quiser, basta referenciar essa variável contendo a imagem como uma próxima etapa para o algoritmo ou para a rede que fará a manipulação desejada, como por exemplo o upscale. Nesse exemplo, deixo ao final uma linha de comando para salvar a imagem em um arquivo
…
imgs = pipe(prompt, generator=generator).imagesresultado = imgs[1]
resultado.save(“resultado.png”)
Olá Wellington!
Esse “seed = 777″ ficou ali inicialmente pois a ideia era reaproveitar essa parte das aulas anteriores e mostrar como o código era reaproveitável, porém logo nos primeiros exemplos com o modelo gerado pelo fine-tuning ficou mais interessante deixar um trecho de código que gera um valor aleatório para o seed a cada execução. Assim é melhor nesse contexto já que agora é um cenário de uma aplicação mais realista e nesses casos você geralmente vai querer fazer testes com vários seeds e portanto é conveniente deixar eles aleatórios. E a vantagem de gerar o seed no programa é que conseguimos printar ele, assim caso gere uma sequência de imagens que achemos interessante nós podemos anotar o seed e trabalhar melhor os ajustes nos parâmetros (para melhorar certos aspectos da imagem por exemplo) usando esse valor como seed para a próxima geração (aí basta definir manualmente, igual com o “seed = 777”).Olá Heitor!
Você está executando no Colab mesmo? Ou em qual ambiente / sistema operacional?
Recomendo reiniciar a sessão e tente checar se executou na ordem todas as mudanças necessárias para compilação do Darknet (se possível tente clonar novamente o repositório antes). Caso o erro persista, por gentiliza compartilhe aqui o seu Colab pois assim consigo te auxiliar melhor e verificar se pode não haver alguma outra coisa no código ou na instalação interferindo.
E caso esteja executando em outro serviço cloud (como o AWS por exemplo) dê uma olhada nessa solução aqui.
Olá! Na verdade os comandos você executa no prompt mesmo (todos os comandos que possuem ! no Colab, porém localmente você vai executar sem a exclamação no início), e depois de feita as instalações você executa o código no PyCharm. Só certifique antes que está executando no PyCharm com o ambiente virtual que você instalou o diffusers, já que você pode ter mais de um ambiente.
Caso você esteja executando no Windows saiba que é bem comum dar algum problema de incompatibilidade, pelo menos alguns têm reclamado quanto a isso, então se for o seu caso eu sugiro dar uma olhada nesse guia e seguir os passos, pois essa parece ser atualmente a forma mais garantida.
Olá Edinalso!
Para a implementação do Stable Diffusion nesse curso foi feito baseado em código, pois permite algumas vantagens e ainda a possibilidade de deixar “programático” e facilmente reproduzível. Mas caso você deseje executar localmente e usando interfaces então saiba que pode sim sem problemas, assim como no método mostrado no artigo de exemplo, porém aqui você não usará mais comandos ou código, você ficará dependente da interface e portanto para gerar as imagens terá que fazer a partir das opções do menu presente nelas (o que é simples, pelo menos a maioria das interfaces usadas para implementar o SD hoje são bastante intuitivas).
No entanto, se você deseja instalar localmente usando essa mesma implementação do curso (que é baseada em código) então basta executar os mesmo comandos, para clonar o repositório oficial do diffusers e então importar as funções necessárias. Caso tenha qualquer dúvida enquanto você estiver tentando usar localmente fique à vontade para perguntar, nós iremos auxiliar.
Olá Rafael!
Eu testei novamente todo o código da aula (treinamento e teste) e não gerou esse erro, rodou sem problemas. Pode ter ocorrido ou algum problema na hora de salvar o modelo treinado, ou ficou diferente alguma parte do seu código.
Em todo o caso, considerando a possibilidade que seja a segunda opção, sugiro dar uma olhada aqui no código da aula: https://colab.research.google.com/drive/11aOxCRQegn6GbpOzoHeO6pVq5K7bRzHc#scrollTo=Lnz1W0v97fR6
Caso persista, tente carregar o modelo disponibilizado na pasta do Drive (o arquivo “rede_neural”).
Se ainda estiver com dificuldades para resolver, peço que compartilhe o seu Colab, pois assim vou conseguir auxiliar melhor, já que pode haver outra coisa em seu código interferindo.
Olá! Esse cascade que você cita foi treinado com imagens do “frontal CALTECH dataset”, nesse github há mais detalhes caso tenha curiosidade.
Mas para treinar seu próprio detector de faces, pode usar imagens positivas de qualquer dataset que contenha na imagem o “objeto” que você deseja detectar; e as negativas seriam qualquer outra coisa que não contenha o seu objeto.
Tem alguns datasets bastante conhecidos e usados (principalmente em trabalhos de pesquisa) como o AT & T Database e o Yale Face Database B. Na verdade, há tantos datasets que vou deixar abaixo dois artigos que reúne dezenas deles:
Você pode dar uma olhada neles e escolher qual se adequada melhor aos seus objetivos, ou também nada impede de usar múltiplos datasets (o que pode ser o ideal caso deseja tornar seu modelo mais robusto).
Olá Fernando!
Para ler imagens nesse formato, você pode usar a própria biblioteca matplotlib (exemplo). Ou, você pode usar a função open() da biblioteca PIL, que já possui suporte a esse formato (mais detalhes aqui). Algumas pessoas já relataram certo problema ao tentar ler esse formato no geral, então como alternativa o que eu recomendo caso isso aconteça com você é fazer antes a conversão do formato .tiff para o .jpg ou .png (png de preferência, para evitar compressão) caso isso não comprometa a sua imagem, claro; assim, você terá uma garantia que poderá carregar suas imagens sem problemas de compatibilidade, pois são formatos mais “universais” e aceitos pelas bibliotecas mais comuns de machine learning e visão computacional. A conversão pode ser feita manualmente usando uma ferramenta como o convertIO, mas se você está trabalhando com muitas imagens isso não é viável, então você pode utilizar um script em python para fazer isso de modo automático, desse modo.
Olá Roberto!
Nesse curso você encontra diversas abordagens usadas para segmentação, se a ideia for construir esse programa do zero então encontrará as técnicas de segmentação que são envolvidas nesse processo. Se o seu objetivo é fazer isso voltado para reconhecimento de caracteres, sugiro dar uma olhada também no nosso outro curso Reconhecimento de Textos – com OCR e Python, em um dos projetos mostra como treinar do zero um modelo para fazer a classificação de caracteres – porém é uma abordagem baseada em redes neurais artificiais.
Entretanto, se entendi bem a descrição do seu problema, eu acho que ele se refere a classificar números digitais com base no preenchimento ou não de determinadas regiões. Há um artigo que explica como fazer exatamente isso, você pode visualizá-lo aqui. Nesse artigo o autor explica detalhadamente como criar uma lógica de segmentação+classificação usando como base o display de sete segmentos, que é a forma mais popular e conhecida para exibição de números digitais. Acredito que seria bem próximo ou até exatamente o que você precisa, mas caso não seja, peço que forneça mais detalhes do seu projeto.
Opa! Disponha, Carlos! Que bom que funcionou bem para você =)
Realmente o tempo de processamento pode ser bem elevado nesses casos pois o OCR é executado dezenas de vezes na mesma imagem, por isso é bem interessante pensar nessas formas de otimização que você comentou. O que ajuda bastante é processar na GPU, caso já não esteja fazendo isso. Mas no geral, para aperfeiçoar a performance em si vai exigir muita tentativa e erro para tentar ajustar ao máximo, por exemplo se for manter a detecção de círculos em seu algoritmo é interessante testar com diferentes parâmetros para manter somente os círculos mais perfeitos ou não tão pequenos – dá para facilmente criar um filtro com base na área em pixels do círculo, assim ignorando os círculos muito pequenos ou muito grandes detectados na imagem e que portanto seriam falsos-positivos, já que todos os círculos de interesse (que possuem o número dentro) tem o mesmo tamanho.
Em último caso, se a sua aplicação não exigir que o resultado seja apresentado instantaneamente no mesmo segundo então seria interessante se concentrar mais agora em maneiras de garantir a precisão do que garantir a velocidade, portanto seguindo essa mesma lógica já pode ser o suficiente.
Olá!
Primeiramente parabéns pelo seu resultado, e obrigado por contribuir apresentando sua solução!
Realmente encontramos essa limitação ao usar a versão gratuita do Colab, devido à memória oferecida pela GPU, o que pode ser um problema ao tentar definir parâmetros muito robustos para alguns algoritmos (como é especialmente o caso do CNN) que exigem um poder computacional muito maior. Mas conforme você comprovou, nesses casos é possível encontrar um modo bem mais otimizado e ainda assim bem preciso usando esses algoritmos mais leves como o Haarcascade.
Olá,
- Sim, os dois valores são alocados individualmente, por isso que os dois somados não devem exceder a sua memória.
- Os dois estão igualmente relacionados ao uso e alocação da memória durante processos da etapa de treinamento, o algoritmo de treinamento do OpenCV faz a distinção entre os dois, porém na prática a recomendação é que esses valores sejam iguais. Mas caso queira saber detalhes mais técnicos sobre a diferença:
- “Valores de features pré-calculadas” se refere aos valores numéricos intermediários que são calculados durante o processo de avaliação de features/características do tipo Haar (Haar-like features) nas amostras de treinamento. Esses valores são basicamente o resultado daqueles cálculos matemáticos baseados nas intensidades de pixels das regiões da imagem (representado por aqueles “quadradinhos” preto e branco, conforme mostrado na aula teórica); ao pré-calcular esses valores e armazená-los na memória, o processo de treinamento pode se tornar mais eficiente. Ou seja, esse parâmetro permite controlar a memória alocada especificamente para esses valores.
- “Índices de features pré-calculadas” se referem aos índices ou posições das características do tipo Haar que são computadas dentro do conjunto de features. Esses índices ajudam a rastrear quais features foram avaliadas em uma determinada amostra durante o processo de treinamento; ou seja, ao pré-calcular e armazenar esses índices o OpenCV pode otimizar o processo de treinamento pois evita avaliações redundantes das mesmas features nas mesmas amostras, já que essas informações podem ser rapidamente acessadas na memória.
