Forum Replies Created
- Posts
Olá Robson!
Esse aviso aparece porque para usar a API da OpenAI é necessário pagar pelo uso, eles não oferecem mais uso gratuito através desse modo.
Para acessar as informações de cobrança e adicionar um método de pagamento para acessar a API, visite https://platform.openai.com/settings/organization/billing/overviewDá para começar com apenas U$5,00, o que parece pouco mas só isso já garante bastante uso mesmo. Consulte a página https://openai.com/api/pricing/ para verificar quantos centavos de dólar são necessários para cada milhão de tokens processados.
Lembrando que o método com o Hugging Face Hub mostrado no curso é gratuito, então pode usar ele para começar caso se sinta mais confortável, e depois que estiver com sua aplicação devidamente testada e ajustada você pode escolher uma opção paga como a Open AI.
Quanto a esse erro com o Ollama, pode ocorrer por vários motivos, mas geralmente é devido a alguma etapa na instalação e configuração ou até mesmo alguma configuração no sistema operacional e que bloqueia a conexão.
Ao seguir a aula “Execução local com Ollama”, apareceu algum erro para você?
Experimente abrir novamente o terminal conforme mostrado em aula, e execute ollama run phi3 (ou o outro modelo que estiver querendo usar) e após terminar de rodar o processamento no terminal volte a executar o código .py pelo VS code. E verifique também se o seu Ollama está atualizado e na versão mais recente.
Olá Leandro!
Aumentar o tamanho da imagem é útil se o objeto a ser detectado tiver detalhes finos que são importantes para a correta classificação. Isso ocorre porque imagens maiores podem capturar melhor esses detalhes, permitindo que o classificador aprenda características mais sutis. Também é benéfico quando o objeto é pequeno em relação ao fundo (entre as imagens usadas para treinamento e teste) e precisa de mais resolução para ser identificado corretamente.
Aumentar o número de imagens positivas é indicado no geral para que o classificador aprenda a detectar com mais precisão, pois isso dá mais exemplos de como o objeto aparece em diferentes condições (iluminação, ângulos, variações), melhorando a sua generalização. Para um classificador realmente bom recomenda-se utilizar umas 5000 imagens (não é exigido tudo isso, pode usar metade ou até menos em seus testes iniciais, mas aqui quanto mais imagens melhor. Só lembrado que isso pode deixar o treinamento muito lento). Então, a verdade mesmo é que não há uma regra de quantas utilizar.
Um detalhe importante também é sobre a qualidade das imagens usadas no treinamento, se estão em uma resolução boa e nítida e com bastante variações por exemplo. Um classificador com 1000 imagens bem selecionadas pode ser melhor que um com 5000 imagens “ruins”, que podem acabar confundindo o modelo. Se você quer um classificador mais robusto (que atenda uma grande variedade de cenários e situações) então será necessário coletar manualmente imagens positivas desse objeto sob diferentes condições. Para objetos mais rígidos (como uma logo) da para usar apenas o createsamples para gerar amostras a partir das imagens de treinamento.
Já aumentar o número de imagens negativas é fundamental caso esteja cometendo muitos erros falsos positivos (identificando coisas que não são o objeto como sendo o objeto). Desse modo o classificador consegue aprender melhor a distinguir entre o que é e o que não é o objeto-alvo.
Ou seja, a escolha ideal do que alterar depende dos desafios específicos que você está enfrentando nos experimentos com o treinamento.
Para mais detalhes sobre como ajustar os parâmetros de treinamento e sobre como melhorar o desempenho, consulte a aula “Melhorias e parâmetros haarcascades”.
Olá João!
No YOLOv8 são disponibilizados modelos pré-treinados em diferentes tamanhos, como por exemplo o Nano (YOLOv8n) e o Small (YOLOv8s).
A ideia é a mesma, usá-los como “ponto de partida”, mas a diferença é que o v8 permite treinar modelos em arquiteturas de diferentes tamanhos, então você pode ter essa opção para escolher. Isso é explicado detalhadamente na seção “YOLOv8”, recomendo dar uma olhada caso ainda tenha dúvidas pois lá explica o conceito dos tamanhos e mostra o código para implementação do treinamento.
Olá!
Primeiramente, vocês podem também executar pelo Colab usando apenas CPU ou localmente sem GPU, basta usar o Hugging Face Hub conforme explicado na aula “Outros serviços para modelos”. Isso te permite rodar modelos LLM de forma prática, mesmo sem hardware adequado. Outra alternativa seria se conectar via API usando LLMs pagas, como a Open AI (mas pelo Hugging Face Hub você pode fazer isso gratuitamente).
Já se quiser usar com a GPU do seu notebook é necessário que a biblioteca CUDA esteja corretamente instalada e configurada. A GeForce MX450 é compatível com CUDA, mas você precisa garantir que os drivers da NVIDIA e a versão correta do CUDA Toolkit estejam instalados.
Primeiro, verifique se o PyTorch está compilado com suporte para CUDA. Você pode instalar o PyTorch com a versão CUDA compatível através do comando de instalação presente no site oficial do PyTorch (https://pytorch.org/) – abaixo de “Install PyTorch”.
Oi! Não se preocupe, esse é um tema que parece meio confuso mesmo e pode demandar certo tempo para adquirir a intuição necessária, então fique tranquila que durante o processo de aprendizagem vai fazer mais sentido para você 😉
Mas quanto à duvida, sim, acredito que você pode sim combinar as duas técnicas para alcançar seu objetivo. Para localizar os pontos de interseção no gráfico, uma abordagem eficaz seria realizar um pré-processamento usando técnicas de visão computacional e processamento de imagem conforme comentei na resposta anterior, como a detecção de bordas com OpenCV, desse modo permitindo você encontrar automaticamente essas interseções. A partir daí, você extrai as coordenadas (x, y) dos pontos de interseção.
A U-Net, por outro lado, poderia talvez ser usada para gerar a segunda imagem, ou seja, o gráfico final. Nesse caso, uma sugestão também seria procurar por papers que usam U-Net (ou outra rede) para reconstruir uma imagem com base na imagem original, estudar a real possibilidade disso na prática, pois creio que pode servir de inspiração (sugiro procurar nos repositórios por termos em inglês, como “unet image reconstruction”).
A U-Net é poderosa mesmo para segmentação de imagens, mas para a tarefa de encontrar as coordenadas exatas, métodos tradicionais de processamento de imagem podem ser mais adequados. Uma vez que você tenha as coordenadas das interseções (obtidas via processamento de imagem), pode utilizá-las para gerar o novo gráfico, traçando as linhas no local correto.
Para reconstruir esse gráfico a partir dos pontos de interseção que você extrair (coordenadas x, y), será necessário implementar um algoritmo que transforme esses valores em uma visualização gráfica. Esse algoritmo será responsável por organizar os pontos em uma estrutura coerente para o traçado da curva ou das linhas desejadas. Uma vez que você tenha as coordenadas, uma ótima opção é utilizar bibliotecas como Matplotlib ou Seaborn, que são amplamente usadas em Python para visualização de dados. Elas permitem gerar gráficos de alta qualidade e personalizáveis, garantindo imagem precisa e clara.
Ou seja, em seu projeto você vai usar uma combinação de diferentes bibliotecas, como as abaixo (ou outra de sua preferência, com o mesmo objetivo)
- OpenCV para o pré-processamento da imagem (detecção de bordas com cv2.Canny() ou cv2.findContours() para detectar as curvas).
- NumPy para lidar com os arrays de coordenadas.
- Matplotlib para gerar o novo gráfico com base nas coordenadas extraídas dos pontos de interseção.
- TensorFlow/Keras ou PyTorch para treinar e usar a U-Net, caso você precise de uma abordagem mais robusta para segmentação de imagem.
Portanto, uma solução pode ser: (1) pré-processar a imagem para detectar os pontos de interseção, (2) extrair as coordenadas desses pontos e (3) usar essas coordenadas para gerar um novo gráfico com Matplotlib ou outro pacote de visualização. Isso evitaria a necessidade de uma rede neural para a parte de detecção das interseções, simplificando o processo.
Olá Douglas!
Isso é devido a uma atualização recente do tensorflow, onde é necessário um pequeno ajuste. Na verdade, você tem duas opções: ou usar uma versão anterior, ou fazer esse ajuste.
Se optar por usar uma versão anterior (por exemplo a 2.12.0 — mas pode ser mais recente, só não pode ser uma das últimas) então basta rodar esse comando abaixo antes de todo o código, colocando como o primeiro bloco.
!pip install tensorflow==2.12.0
E após executar isso reiniciar a sessão do Colab. Caso não apareça já automaticamente um botão para reiniciar, basta ir em ‘Ambiente de execução > reiniciar sessão’. Com isso vai funcionar e não precisa fazer nenhum ajuste.
A outra opção é fazer um pequeno ajuste. Após uma atualização recente do tensorflow é necessário agora usar get_layer() para a camada de input, igual é feito com a camada de output.
Ou seja, ao invés de autoencoder.input agora vai ser: autoencoder.get_layer(‘dense’).input
você deve substituir isso no parâmetro inputs em “encoder = Model()“. ficando assim:
encoder = Model(inputs = autoencoder.get_layer(‘dense’).input, outputs = autoencoder.get_layer(‘dense_2’).output)
Observação: além desse trecho, também será preciso mudar lá logo abaixo da seção “Codificação e decodificação das imagens de teste”, alterando de autoencoder.input para autoencoder.get_layer(‘conv2d’).input
Olá, eu acredito que conseguiria sim reconstruir a imagem usando técnicas tradicionais (isso se entendi corretamente o que você quis dizer que “reconstruir”, que seria criar esse gráfico que você mandou por último). Caso o interesse seja segmentar a linha (e não apenas retornar a localização do ponto de intersecção) então teria vantagem usar o U-Net ou outra abordagem para segmentação de imagem, pois através da segmentação você retornaria o desenho da linha no gráfico, já com detecção você poderá obter somente a região do ponto de intersecção na imagem e as coordenadas dessa região de interesse (ROI).
Mas caso você precise apenas achar o ponto x,y na imagem e não segmentar a linha então penso que a U-Net não teria uma vantagem nesse contexto, já que o retorno da U-net no final das contas é basicamente uma máscara do “objeto” segmentado (nesse caso, objeto é o ponto de intersecção). Ou seja, ao final do processamento da rede neural você terá uma imagem binarizada que representa o “objeto” com um cor e o fundo (tudo o que não é o objeto) com outra. Mas talvez tenha outro detalhe em relação ao que você deseja fazer e que faça o U-Net ser mais vantajosa, essa minha opinião acima seria com base apenas no que entendi quanto à questão que você apresentou na pergunta.
Mesmo assim, se ideia é segmentar a região eu aconselho testar também as técnicas tradicionais mostradas na primeira seção do curso, por exemplo a técnica de limiarização (thresholding). É um método mais simples mas que pode ser bastante eficaz para imagens digitais, que possuem menos variação de tons de cores. Aliás, se todas as imagens que você fará o processamento forem semelhantes e possuírem o mesmo estilo de gráfico por exemplo, então esses métodos tradicionais podem ser o suficiente. Já se as imagens de gráficos que serão testadas possuírem muitas diferenças entre si então faz mais sentido usar técnica baseada em deep learning como U-Net, pois irão ser mais robustas e funcionar melhor para uma gama maior de imagens e sem exigir customização individual de parâmetros.
Quanto à possibilidade de extrair as coordenadas desse segmento na imagem, dá para fazer isso tanto usando os métodos com deep learning quanto métodos com processamento de imagem (por exemplo assim). Ou seja, de qualquer forma poderá obter as coordenadas de localização desse ponto na imagem, podendo usar para gerar uma imagem semelhante à que você forneceu. E para obter esses valores dos eixos X e Y em uma imagem de gráfico, é possível usar técnicas de processamento de imagem como detecção de bordas ou contornos para identificar elementos relevantes, como curvas ou interseções (ou a técnica de limiarização, que citei acima). Uma vez detectado o ponto de interesse – nesse caso, ponto de interseção – as coordenadas desse ponto podem ser extraídas em termos de pixels. Com essas coordenadas em pixel, você pode realizar uma calibração comparando os pixels com os valores reais dos eixos. Isso é feito associando pontos de referência conhecidos no gráfico aos seus valores correspondentes no eixo (por exemplo, associar um ponto específico no gráfico ao valor de 3.5 no eixo X e 1 no eixo Y). Dessa forma, é possível converter as coordenadas de pixel em valores reais do gráfico, permitindo a leitura precisa das variáveis como tempo (Y) e velocidade (X).
Uma outra sugestão seria que você combine ambas as abordagens: comece com o processamento de imagem tradicional para pré-processar ou até mesmo identificar os pontos de interesse, e, em seguida, use uma U-Net ou outra rede neural adequada para mapear essas interseções e depois poder gerar a imagem final do perfil de velocidade.
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()
