Jump to content
PARTICIPE DO NOSSO GRUPO DE AVISOS DO FÓRUM

Omesmo

Super VIP
 View Profile  See their activity

  • Posts

    1,652

  • Joined

  • Last visited

  • Days Won

    6

 Content Type 

Posts posted by Omesmo

    IAs ajudando a montar planilhas de loteria

    in Dicas de Excel para Loterias

    Posted

    eu estou sem tempo no gpt 4 entao estou vendo como o gemini se comporta, e digo, falta muito para ele alcançar o gpt mesmo na versão 3.5 , o bicho simplesmente trava, e nao consegue completar nada

     

    só estou tentando desenvolver algumas ideias
     

    Spoiler

    ruzamento com Similaridade Controlada para Algoritmo Genético de Lotofacil

    A ideia de cruzar cromossomos com características similares para aumentar a probabilidade de herança de características desejáveis no algoritmo genético de Lotofacil é interessante e pode ser implementada de diferentes maneiras. Abaixo, exploramos duas abordagens para incorporar a similaridade no processo de cruzamento:

    1. Cruzamento por Similaridade Ponderada:

    • Mecânica:

      • Ao selecionar o ponto de corte para o cruzamento, a probabilidade de corte é ponderada pela similaridade entre os elementos dos cromossomos (pais) naquela posição.
      • Posições com elementos mais similares terão maior probabilidade de serem mantidas no mesmo filho, preservando características desejáveis.
      • Essa ponderação pode ser implementada utilizando funções matemáticas como a distância euclidiana ou medidas de similaridade específicas para o problema da Lotofacil.

    • Exemplo:

      • Se os pais forem [1, 5, 10, 15, 20] e [2, 5, 11, 14, 19], a posição 2 (com elementos 5 em ambos os pais) terá maior probabilidade de ser mantida no mesmo filho, preservando a característica "5" nessa posição.

    • Vantagens:

      • Direciona o cruzamento para preservar características desejáveis com maior probabilidade.
      • Pode acelerar a convergência para soluções otimizadas.
      • Permite controlar o nível de similaridade desejado no cruzamento.

    • Desvantagens:

      • A definição da função de similaridade pode ser complexa e dependente do problema específico.
      • Pode reduzir a diversidade da população se a similaridade for muito alta.
      • Requer ajustes finos para encontrar o balanceamento ideal entre similaridade e diversidade.

    2. Cruzamento por Segmentos Similares:

    • Mecânica:

      • Identifica segmentos contíguos de elementos similares em cada cromossomo (pai).
      • Combina esses segmentos similares dos pais para formar novos filhos.
      • Os segmentos restantes (não similares) são preenchidos com elementos aleatórios ou provenientes do outro pai.

    • Exemplo:

      • Se os pais forem [1, 5, 10, 15, 20] e [2, 5, 11, 14, 19], o segmento similar [5] em ambos os pais seria combinado para formar um filho, e os elementos restantes seriam preenchidos aleatoriamente ou com elementos do outro pai.

    • Vantagens:

      • Preserva com mais precisão segmentos de características desejáveis nos filhos.
      • Permite maior controle sobre quais características específicas devem ser preservadas.
      • Pode ser mais intuitivo e fácil de implementar.

    • Desvantagens:

      • Pode reduzir a diversidade da população se a similaridade for muito alta.
      • Requer a identificação precisa de segmentos similares, o que pode ser desafiador em alguns casos.
      • Pode ser menos eficiente que o cruzamento ponderado em termos de convergência.

    Considerações Adicionais:

    • A escolha entre as duas abordagens ou a implementação de uma alternativa depende das características específicas do problema e dos objetivos do algoritmo.
    • É importante avaliar o impacto da similaridade na diversidade da população e na performance do algoritmo.
    • Ajustes finos nos parâmetros e na estratégia de cruzamento podem ser necessários para otimizar os resultados.

    Recomendações:

    • Testar e comparar diferentes abordagens: Experimente as duas abordagens de cruzamento com similaridade e compare seus resultados em termos de convergência, qualidade das soluções e diversidade da população.
    • Ajustar parâmetros: Ajuste os parâmetros de similaridade (como a função de similaridade ou o tamanho mínimo dos segmentos) para encontrar o equilíbrio ideal entre preservação de características e diversidade.
    • Monitorar a diversidade: Monitore a diversidade da população ao longo das iterações para garantir que não fique muito baixa e prejudique a busca por soluções otimizadas.

    Conclusão:

    A incorporação de similaridade no processo de cruzamento pode ser uma estratégia valiosa para direcionar a busca por soluções otimizadas no algoritmo genético de Lotofacil. As duas abordagens apresentadas, cruzamento ponderado e por segmentos similares, oferecem diferentes trade-offs entre preservação de características, diversidade e simplicidade de implementação. A escolha ideal depende das características específicas do problema e dos objetivos do algoritmo.

     

    • Like 1

    IAs ajudando a montar planilhas de loteria

    in Dicas de Excel para Loterias

    Posted

    um ponto é não colocar as loterias como ponto principal e sim secundario
    tipo ,
     

    Citar

    ola, boa tarde quero fazer um codigo genetico em vba para aprender, vou usar resultados de loteria, talvez a loto facil como dados de treinamento para facilitar e tem como ir adicionando os dados para treinar

    Olá! Que legal que você está se interessando em usar VBA para criar um algoritmo genético e aprender sobre o assunto! Utilizar resultados da Loto Fácil como dados de treinamento é uma ótima ideia para começar, pois facilita o processo e torna tudo mais acessível.

    Para te ajudar da melhor forma, preciso entender melhor seus objetivos e o que você deseja alcançar com o algoritmo genético. Você poderia me fornecer mais detalhes sobre:

    • O que você espera que o algoritmo genético faça? Você quer que ele preveja os próximos números da Loto Fácil? Ou deseja otimizar alguma estratégia de jogo?
    • Quais critérios você utilizará para avaliar a performance do algoritmo? Será que você vai considerar a quantidade de acertos, a premiação total ou outros fatores?
    • Com que frequência você pretende adicionar novos dados de treinamento? Será que você vai atualizar o algoritmo após cada concurso da Loto Fácil ou com menos frequência?

    Com base nas suas respostas, posso te ajudar a criar um código VBA personalizado e te fornecer dicas para treinar o algoritmo de forma eficaz. Além disso, posso te indicar recursos adicionais para aprofundar seus conhecimentos em algoritmos genéticos e VBA.

    Lembre-se que o aprendizado com algoritmos genéticos é um processo contínuo, e pode ser necessário ajustar o código e os dados de treinamento ao longo do tempo para obter melhores resultados.

    Dicas para começar:

    • Colete dados da Loto Fácil: Você pode encontrar os resultados dos concursos anteriores em sites como a Caixa Econômica Federal (https://loterias.caixa.gov.br/Paginas/App/Federal.aspx) ou em APIs online.
    • Prepare os dados para o treinamento: Organize os dados em um formato adequado para o VBA, como uma matriz ou um dataframe.
    • Defina a função objetivo: Determine como o algoritmo irá avaliar a qualidade de cada solução potencial.
    • Implemente o algoritmo genético: Utilize as estruturas de dados e os operadores do VBA para criar os cromossomos, realizar a seleção, o crossover e a mutação.
    • Avalie e refine o algoritmo: Teste o algoritmo com diferentes conjuntos de dados e configurações, e ajuste os parâmetros para otimizar o desempenho.

    Recursos úteis:

    • Documentação do VBA: [URL inválido removido]
    • Tutoriais sobre algoritmos genéticos: [URL inválido removido]
    • Exemplos de código VBA para algoritmos genéticos: [URL inválido removido]

    Lembre-se:

    • É importante ter um conhecimento básico de programação em VBA antes de iniciar este projeto.
    • O processo de aprendizado com algoritmos genéticos pode ser desafiador, mas também é muito recompensador.
    • Não desanime se não obtiver resultados imediatos. Continue experimentando e ajustando o código até alcançar seus objetivos.

    Estou aqui para te auxiliar no seu aprendizado e te ajudar a superar qualquer obstáculo que você encontrar. Sinta-se à vontade para fazer qualquer pergunta que você tiver!

    esse foi no gemini, no gpt 4 ele dá até um condigo, ele tá bem falador
    no gemini tem que ir amaciando e evoloindo a conversa para ele fazer algo util

    • Like 1

    IAs ajudando a montar planilhas de loteria

    in Dicas de Excel para Loterias

    Posted

    2 horas atrás, Wata disse:

    @Omesmo 

    Vc implementou? Funciona?

    Bom, só de ter conseguido que ela faça isso já é algum progresso... porque se pergunto algo sobre loteria sempre levo uma lição de moral primeiro...😁...

     

    😎

    ...

    funcionar até funciona, mas nao 100%, falta muita coisa para isso ficar utilizavel, eu estou fazendo os ajustes aos poucos , inicialmente quero um codico dinamico e funcional para ir adicionando as funções

    o gpt 4 gratuito tem um limite de uso, e nao dá para usar direto até um codigo 100% funcional então tem que esperar para fazer os ajustes
    pelo que vi ela consegue até montar planilhas inteiras mandando uma planilha de exemplo, mas no gratuito nao consegue completar

    • Like 1

    IAs ajudando a montar planilhas de loteria

    in Dicas de Excel para Loterias

    Posted

    14 minutos atrás, PARAFUSO disse:

    é um truque, a IA mente, depois que fiz uma pergunta simples e obtive a resposta vi q não teria ajuda de nenhuma IA da net (pelo menos gratis, paga ja não sei ) pra ganhar na loteria, a pegunta foi a seguinte: vc foi programada pra não ajudar em jogos de loteria aqui no brasil ? a resposta me fez entender q se queremos uma IA pra ajudar a ganhar na loteria temos q criala nos mesmos, como não posso nem sei como larguei mão, continuo com o velho e util ecxel 😭

    cara eu até consigo respostas sobre loteria, claro que as vezes vem cheio de dizeres morais e essas coisas

    • Like 1

    IAs ajudando a montar planilhas de loteria

    in Dicas de Excel para Loterias

    Posted

    acho que o GPT4 está bem util para criar macros para loterias

    um exemplo que to desenvolvendo

    GPT

    Citar

    Para transformar o seu código em algo prático, que possa realmente prever as dezenas do próximo sorteio, é necessário fazer algumas melhorias e ajustes. Vou adicionar algumas funcionalidades, como a definição de uma "saída" prática, métricas de avaliação e ajuste de hiperparâmetros.

    Passos para aprimorar o código:

    1. Melhorar a função de avaliação para refletir o problema específico (previsão de dezenas).
    2. Armazenar e exibir os melhores resultados após a execução.
    3. Adicionar uma função para prever as dezenas do próximo sorteio com base no melhor indivíduo da população.

    Ajustes no código:

    Vou modificar e adicionar alguns trechos para atingir esses objetivos:

    1. Definir a saída prática:

      • A saída prática será uma lista das melhores dezenas previstas.

    2. Melhorar a função de avaliação e métricas:

      • Vou ajustar a função de avaliação para refletir a comparação entre as dezenas previstas e as dezenas reais dos sorteios.

    3. Adicionar uma função para prever as dezenas do próximo sorteio:

      • Após treinar a rede neural e realizar a evolução genética, utilizaremos o melhor indivíduo para prever as dezenas do próximo sorteio.

    Aqui está o código aprimorado: 

    ' Definir parâmetros da rede
Private MaiorDez As Long    ' A maior dezena do conjunto
Private numEntradas As Long    ' Número de neurônios de entrada
Private numOcultas As Long    ' Número de neurônios na camada oculta
Private numSaidas As Long    ' Número de neurônios de saída

Private numLinhas As Long    ' Número de exemplos de treinamento ou pontos de dados
Private taxaAprendizado As Double    ' Taxa de aprendizado para atualizar pesos da rede
Private epocas As Long    ' Número de épocas de treinamento
Private tamanhoPopulacao As Long    ' Tamanho da população (redes neurais evolutivas)
Private CiclosEvolucao As Long    ' Número de ciclos de evolução do algoritmo genético

' Declarar arrays para dados da rede
Private entradas() As Long    ' Valores de entrada para a rede
Private saidas() As Long    ' Valores de saída desejados (saídas alvo)
Private populacao() As Double    ' População (rede neural evolutiva) ou estados intermediários da rede
Private pesosIH() As Double    ' Pesos entre camada de entrada e camada oculta
Private pesosHO() As Double    ' Pesos entre camada oculta e camada de saída
Private biasH() As Double    ' Valores de bias para neurônios da camada oculta
Private biasO() As Double    ' Valores de bias para neurônios da camada de saída
Private saidaObtida As Double
Private somaErros As Double
Private somaErroRelativo As Double
Private acertos As Long
Private saidaDesejada As Double

Private somasOculta() As Double    ' Somas ponderadas das entradas na camada oculta
Private somasSaida() As Double    ' Somas ponderadas das entradas na camada de saída

' Declarar arrays para treinamento e avaliação
Private novaPopulacao() As Double    ' Nova população (rede neural evolutiva)
Private fitness() As Double    ' Valores de aptidão para cada indivíduo (rede neural evolutiva)
Private entrada() As Double    ' Armazenamento temporário para um único ponto de dados de entrada
Private saidasOculta() As Double    ' Ativações dos neurônios da camada oculta
Private erroSaida() As Double    ' Erro entre saída da rede e saída desejada (treinamento)
Private erroOculta() As Double    ' Erro propagado de volta para a camada oculta (treinamento)

Private erroAbsoluto As Double  ' Erro absoluto das previsões da rede
Private erroRelativo As Double    ' Erro relativo das previsões da rede
Private taxaAcerto As Double    ' Acurácia da rede nos dados de treinamento
Private precisao As Double  ' Precisão da rede nos dados de treinamento

Sub Principal()

    Call define_parametros

    ' Carregar os dados da planilha para arrays
    Dim coluna_numero_concurso As Long, coluna_datas As Long, coluna_inicial As Long, linha_inicial As Long, ultima_linha As Long
    coluna_numero_concurso = 1
    coluna_datas = 2
    coluna_inicial = 4    ' Coluna inicial de dados "dezenas"
    linha_inicial = 11    ' Linha que inicia os dados "dezenas"
    ultima_linha = Cells(Rows.Count, coluna_inicial).End(xlUp).Row
    numLinhas = ultima_linha - linha_inicial + 1
    
    ReDim entradas(numLinhas + 1, numEntradas + 1)
    ReDim saidas(numLinhas + 1)
    Dim i As Long, j As Long

    For i = 1 To numLinhas
        For j = 1 To numEntradas
            entradas(i, j) = Cells(i + linha_inicial, coluna_inicial + j - 1).Value2   ' Pega dados da aba ativa
        Next j
        saidas(i) = Cells(i + linha_inicial, coluna_inicial + numEntradas).Value2    ' Pega dados da aba ativa
    Next i

    ReDim pesosIH(numEntradas, numOcultas)
    ReDim pesosHO(numOcultas, numSaidas)
    ReDim biasH(numOcultas) As Double
    ReDim biasO(numSaidas) As Double
    ReDim populacao(tamanhoPopulacao, numEntradas)
    ReDim novaPopulacao(tamanhoPopulacao, numEntradas)
    ReDim fitness(tamanhoPopulacao)
    ReDim entrada(numEntradas)
    ReDim somasOculta(numOcultas)
    ReDim saidasOculta(numOcultas)
    ReDim somasSaida(numSaidas)
    ReDim erroSaida(numSaidas)
    ReDim erroOculta(numOcultas)
    Call InicializarPesos
    Call TreinarRedeNeural
    Call AlgoritmoGenetico
    Call ExibirResultados
End Sub

Sub define_parametros()
    ' Definir as dimensões
    MaiorDez = 60
    numEntradas = 6
    numOcultas = 10
    numSaidas = 1

    tamanhoPopulacao = 101
    CiclosEvolucao = 1000
    taxaAprendizado = 0.1
    epocas = 1000
End Sub

Sub InicializarPesos()
    Dim i As Long, j As Long
    Randomize
    For i = 1 To numEntradas
        For j = 1 To numOcultas
            pesosIH(i, j) = Rnd
        Next j
    Next i
    
    For i = 1 To numOcultas
        For j = 1 To numSaidas
            pesosHO(i, j) = Rnd
        Next j
    Next i
    
    For i = 1 To numOcultas
        biasH(i) = Rnd
    Next i
    
    For i = 1 To numSaidas
        biasO(i) = Rnd
    Next i
End Sub

Sub TreinarRedeNeural()
    Dim i As Long, j As Long, k As Long

    For epoca = 1 To epocas
        For i = 1 To numLinhas
            ' Propagação para frente
            For j = 1 To numOcultas
                somasOculta(j) = biasH(j)
                For k = 1 To numEntradas
                    somasOculta(j) = somasOculta(j) + entradas(i, k) * pesosIH(k, j)
                Next k
                saidasOculta(j) = Sigmoid(somasOculta(j))
            Next j
            
            For j = 1 To numSaidas
                somasSaida(j) = biasO(j)
                For k = 1 To numOcultas
                    somasSaida(j) = somasSaida(j) + saidasOculta(k) * pesosHO(k, j)
                Next k
                saidaObtida = Sigmoid(somasSaida(j))
            Next j
            
            ' Retropropagação
            For j = 1 To numSaidas
                erroSaida(j) = saidas(i) - saidaObtida
                For k = 1 To numOcultas
                    pesosHO(k, j) = pesosHO(k, j) + taxaAprendizado * erroSaida(j) * saidasOculta(k)
                Next k
                biasO(j) = biasO(j) + taxaAprendizado * erroSaida(j)
            Next j
            
            For j = 1 To numOcultas
                erroOculta(j) = 0
                For k = 1 To numSaidas
                    erroOculta(j) = erroOculta(j) + erroSaida(k) * pesosHO(j, k)
                Next k
                erroOculta(j) = erroOculta(j) * saidasOculta(j) * (1 - saidasOculta(j))
                For k = 1 To numEntradas
                    pesosIH(k, j) = pesosIH(k, j) + taxaAprendizado * erroOculta(j) * entradas(i, k)
                Next k
                biasH(j) = biasH(j) + taxaAprendizado * erroOculta(j)
            Next j
        Next i
    Next epoca
End Sub

Function Sigmoid(x As Double) As Double
    Sigmoid = 1 / (1 + Exp(-x))
End Function

Sub AlgoritmoGenetico()
    Dim i As Long, j As Long, k As Long
    Dim MelhorIndividuo As Long, MelhorFitness As Double
    Dim pai1 As Long, pai2 As Long, filho As Long
    Dim crossoverPoint As Long
    Dim mutacaoChance As Double
    Randomize

    For i = 1 To tamanhoPopulacao
        For j = 1 To numEntradas
            populacao(i, j) = Rnd * MaiorDez
        Next j
    Next i

    mutacaoChance = 0.05

    For ciclo = 1 To CiclosEvolucao
        MelhorFitness = 0
        MelhorIndividuo = 1
        For i = 1 To tamanhoPopulacao
            fitness(i) = AvaliarIndividuo(i)
            If fitness(i) > MelhorFitness Then
                MelhorFitness = fitness(i)
                MelhorIndividuo = i
            End If
        Next i

        For i = 1 To tamanhoPopulacao
            pai1 = SelecionarIndividuo
            pai2 = SelecionarIndividuo
            crossoverPoint = Int((numEntradas - 1) * Rnd) + 1
            For j = 1 To crossoverPoint
                novaPopulacao(i, j) = populacao(pai1, j)
            Next j
            For j = crossoverPoint + 1 To numEntradas
                novaPopulacao(i, j) = populacao(pai2, j)
            Next j

            For j = 1 To numEntradas
                If Rnd < mutacaoChance Then
                    novaPopulacao(i, j) = Rnd * MaiorDez
                End If
            Next j
        Next i

        For i = 1 To tamanhoPopulacao
            For j = 1 To numEntradas
                populacao(i, j) = novaPopulacao(i, j)
            Next j
        Next i
    Next ciclo

    ' Prever o próximo sorteio com base no melhor indivíduo
    For j = 1 To numEntradas
        Cells(1, j) = populacao(MelhorIndividuo, j)
    Next j
End Sub

Function AvaliarIndividuo(individuo As Long) As Double
    Dim i As Long, j As Long
    Dim errosTotais As Double

    errosTotais = 0
    For i = 1 To numLinhas
        errosTotais = errosTotais + Abs(saidas(i) - populacao(individuo, 1))
    Next i

    AvaliarIndividuo = 1 / (1 + errosTotais)
End Function

Function SelecionarIndividuo() As Long
    Dim i As Long
    Dim somaFitness As Double
    Dim valorSorteado As Double
    Dim fitnessAcumulado As Double

    somaFitness = 0
    For i = 1 To tamanhoPopulacao
        somaFitness = somaFitness + fitness(i)
    Next i

    valorSorteado = Rnd * somaFitness
    fitnessAcumulado = 0

    For i = 1 To tamanhoPopulacao
        fitnessAcumulado = fitnessAcumulado + fitness(i)
        If fitnessAcumulado >= valorSorteado Then
            SelecionarIndividuo = i
            Exit Function
        End If
    Next i

    SelecionarIndividuo = tamanhoPopulacao
End Function

Sub ExibirResultados()
    Dim i As Long, j As Long
    Dim MelhorIndividuo As Long, MelhorFitness As Double

    MelhorFitness = 0
    MelhorIndividuo = 1
    For i = 1 To tamanhoPopulacao
        If fitness(i) > MelhorFitness Then
            MelhorFitness = fitness(i)
            MelhorIndividuo = i
        End If
    Next i

    ' Exibir os resultados das previsões
    For j = 1 To numEntradas
        Cells(1, j).Value = populacao(MelhorIndividuo, j)
    Next j
End Sub

     

    GPT

    Citar

    Como funciona:

    1. Principal: Função principal que define os parâmetros, carrega os dados, inicializa a rede neural e os pesos, treina a rede neural, executa o algoritmo genético e exibe os resultados.
    2. define_parametros: Define os parâmetros da rede neural e do algoritmo genético.
    3. InicializarPesos: Inicializa os pesos e bias das camadas da rede neural.
    4. TreinarRedeNeural: Treina a rede neural usando retropropagação.
    5. Sigmoid: Função de ativação sigmoide.
    6. AlgoritmoGenetico: Implementa o algoritmo genético para evoluir a população de redes neurais.
    7. AvaliarIndividuo: Avalia a aptidão de um indivíduo com base nos erros totais.
    8. SelecionarIndividuo: Seleciona um indivíduo com base na roleta de fitness.
    9. ExibirResultados: Exibe os resultados das previsões na primeira linha da planilha.

    Nota:

    Este código é uma implementação básica e serve como ponto de partida. Melhorias adicionais podem ser feitas, como otimizações mais complexas, ajustes finos de hiperparâmetros, técnicas de regularização, e exploração de arquiteturas de rede mais sofisticadas. A precisão dos resultados dependerá da qualidade e quantidade dos dados de entrada.

     

    bem eu fui fazendo pedidos e adaptando,

    uma coisa que fiz foi definir variaveis publicas, porque quando cria as funções com Byref, se tem um monte de chamadas e isso gasta o uso gpt4 com beisteiras , bem esse codigo aí ainda nao testei, mas o outro eu tive que corrigir varias coisas, nao sei se algumas eu que causei com as modificações
    estou tentando montar algo para qualquer loteria e ir melhorando, quem sabe se ficar realmente bom transformar em uma dll para ficar mais rapido

    • Like 2

    foruns de excel sendo desativados

    in Dicas de Excel para Loterias

    Posted

    vi muitos foruns de excel que eu frequentei sendo desativados ou deixados  a moscas
    será um abandono do excel em si ou do estilo forum para tirar duvidas?

    de certa forma hoje em dia com as ia muitas duvidas ficam mais facil ser resolvidas com eles, um fato são respostas instantaneas

    mas muitas duvidas nao tem como tirar com as ias , simplesmente por que as vezes as pessoas nao sabem nem por onde começar

    o forum aqui se tivesse uma sessão separada só para o excel puro  tavez atraísse o pessoal que ficou órfão desses foruns que estão sendo fechados 
     

    mas bem,

    apesar do meu desanimo eu ainda acho o excel uma ferramenta incrível , tem varias funcionalidade com possibilidade de automatizar tarefas e concretizar ideias muito rapidamente .
    agora com ajuda das ias pode ter um papel importante em concretizar ideias que antes nao se sabia como colocar em pratica
    o gpt4 tá muito avançado, apesar de ainda cometer erros graves,

    já o gemini antigo bard tá engatinhando ainda, consegue ser pior do que o gpt quando começou , muitas vezes ele responde em ingles apesar de pedir para responder em portugues, e muitas vezes se recusa a fazer o que a gente quer  e fica se repetindo como se estivesse apenas copiando e colando

    • Like 4

    O maravilhoso mundo do sequenciamento aleatório

    in Matemática e Estatísticas

    Posted

    Em 17/05/2024 em 16:31, RobSmith disse:

    O objetivo do autor, desenvolver uma linguagem que conecta logicamente números aleatórios usando expressões metamórficas e anatômicas para prever números futuros.

    Váriaveis =  tempo, datas calendários, numeros do volante, multiplicadores de loteria sequenciais, estados (statements) e expressão binária.

    basicamente é tudo o que nós aqui procuramos, e que toda ideia maluca tenta desenvolver , misturamos tudo e mais um pouco para ver se encontramos uma ligação entre os varios acontecimentos
    estatisticamente falando é um trabalho árduo e inglório , bem nem por isso deixamos de procurar

    "FUGA DAS BOLINHAS" o dia que as bolinhas tentaram fugir do globo do sorteio QUINA

    in Tudo sobre Loterias

    Posted

    1 hora atrás, genesioggs23 disse:

    Alguém aqui sabe alguma forma de descobrir alfuma dz que será sorteada no concurso do dia, não importa a loteria, pode ser Quina, Mega Sena, Dia de Sorte, Timemania, Dupla Sena, Super Sete, Lotofácil, Lotomania e ou +Milionária, se alguém souber por favor poste aqui as informações ok? Obrigado a todos!!!

    acho que é impossivel isso, mesmo se alguem descobrir como ter certeza de pelo menos 1 dezena que vai ser sorteada nunca vai contar

    Mudanças no Fórum - O que você gostaria que mudasse?

    in Notícias do Fórum

    Posted

     @Jimmy   acho que uma adição legal seria uma area só para uso de IAs nas loterias, agora com o gpt e o gemini facilitando muito o estudo e desenvolvimento , com o novo gpt 4 suportanto 25 mil palavras dá até para ter um projeto mais complexo
    tipo um exemplo que fiz de teste com o novo gpt no modo gratuito


    EU: "voce conseguiria juntar tudo numa coisa só mas trabalhando com matrizes de 15 colunas x 4 mil linhas com dezenas de 1 a 80?"
    GPT4:

    Claro, vamos criar um projeto VBA que integra uma rede neural, algoritmo genético e regressão linear em uma única planilha, trabalhando com matrizes de 15 colunas x 4000 linhas com dezenas de 1 a 80. Vou dar uma estrutura básica para cada componente e depois juntar tudo.

    Passos:

    1. Estrutura do Projeto:

      • Criar uma planilha chamada "Dados" onde os dados serão armazenados.
      • Criar uma planilha chamada "Resultados" onde os resultados serão exibidos.

    2. Rede Neural:

      • Adaptação da rede neural para lidar com 15 entradas e 4000 exemplos de treinamento.

    3. Algoritmo Genético:

      • Ajustar para 15 genes em cada indivíduo.

    4. Regressão Linear:

      • Ajustar para prever valores baseados em uma coluna específica.

    Código Integrado: 

    Sub ProjetoIntegrado()
    ' Inicializar dados e parâmetros
    Dim entradas(1 To 4000, 1 To 15) As Double
    Dim saidas(1 To 4000) As Double
    
    Dim pesosIH(1 To 15, 1 To 10) As Double ' Pesos entre camada de entrada e oculta
    Dim pesosHO(1 To 10, 1 To 1) As Double ' Pesos entre camada oculta e saída
    
    Dim biasH(1 To 10) As Double ' Biases da camada oculta
    Dim biasO(1 To 1) As Double ' Bias da camada de saída
    
    Dim taxaAprendizado As Double
    taxaAprendizado = 0.1 ' Taxa de aprendizado
    
    ' Inicializar pesos e biases com valores aleatórios
    Dim i As Integer, j As Integer
    For i = 1 To 15
        For j = 1 To 10
            pesosIH(i, j) = Rnd
        Next j
    Next i
    For i = 1 To 10
        For j = 1 To 1
            pesosHO(i, j) = Rnd
        Next j
    Next i
    For i = 1 To 10
        biasH(i) = Rnd
    Next i
    For i = 1 To 1
        biasO(i) = Rnd
    Next i
    
    ' Carregar dados da planilha "Dados"
    Dim wsDados As Worksheet
    Set wsDados = ThisWorkbook.Sheets("Dados")
    
    For i = 1 To 4000
        For j = 1 To 15
            entradas(i, j) = wsDados.Cells(i + 1, j).Value
        Next j
        saidas(i) = wsDados.Cells(i + 1, 16).Value
    Next i
    
    ' Treinamento da rede neural
    TreinarRedeNeural entradas, saidas, pesosIH, pesosHO, biasH, biasO, taxaAprendizado
    
    ' Algoritmo genético
    AlgoritmoGenetico
    
    ' Regressão linear
    RegressaoLinear
End Sub

Sub TreinarRedeNeural(ByRef entradas As Variant, ByRef saidas As Variant, _
                      ByRef pesosIH As Variant, ByRef pesosHO As Variant, _
                      ByRef biasH As Variant, ByRef biasO As Variant, _
                      ByVal taxaAprendizado As Double)
    Dim epocas As Integer
    epocas = 1000 ' Número de épocas de treinamento
    
    Dim entrada(1 To 15) As Double
    Dim saidaDesejada As Double
    Dim saidaObtida As Double
    
    Dim somasOculta(1 To 10) As Double
    Dim saidasOculta(1 To 10) As Double
    Dim somasSaida(1 To 1) As Double
    
    Dim erroSaida(1 To 1) As Double
    Dim erroOculta(1 To 10) As Double
    
    Dim i As Integer, j As Integer, k As Integer, epoca As Integer
    
    For epoca = 1 To epocas
        For i = 1 To 4000
            ' Configurar entrada e saída desejada
            For j = 1 To 15
                entrada(j) = entradas(i, j)
            Next j
            saidaDesejada = saidas(i)
            
            ' Propagação para frente
            For j = 1 To 10
                somasOculta(j) = biasH(j)
                For k = 1 To 15
                    somasOculta(j) = somasOculta(j) + entrada(k) * pesosIH(k, j)
                Next k
                saidasOculta(j) = Sigmoid(somasOculta(j))
            Next j
            
            For j = 1 To 1
                somasSaida(j) = biasO(j)
                For k = 1 To 10
                    somasSaida(j) = somasSaida(j) + saidasOculta(k) * pesosHO(k, j)
                Next k
                saidaObtida = Sigmoid(somasSaida(j))
            Next j
            
            ' Propagação para trás (retropropagação)
            For j = 1 To 1
                erroSaida(j) = saidaDesejada - saidaObtida
                For k = 1 To 10
                    pesosHO(k, j) = pesosHO(k, j) + taxaAprendizado * erroSaida(j) * saidasOculta(k)
                Next k
                biasO(j) = biasO(j) + taxaAprendizado * erroSaida(j)
            Next j
            
            For j = 1 To 10
                erroOculta(j) = 0
                For k = 1 To 1
                    erroOculta(j) = erroOculta(j) + erroSaida(k) * pesosHO(j, k)
                Next k
                erroOculta(j) = erroOculta(j) * saidasOculta(j) * (1 - saidasOculta(j))
                For k = 1 To 15
                    pesosIH(k, j) = pesosIH(k, j) + taxaAprendizado * erroOculta(j) * entrada(k)
                Next k
                biasH(j) = biasH(j) + taxaAprendizado * erroOculta(j)
            Next j
        Next i
    Next epoca
End Sub

Function Sigmoid(x As Double) As Double
    Sigmoid = 1 / (1 + Exp(-x))
End Function

Sub AlgoritmoGenetico()
    Dim populacao(1 To 100, 1 To 15) As Integer
    Dim novaPopulacao(1 To 100, 1 To 15) As Integer
    Dim fitness(1 To 100) As Double
    Dim i As Integer, j As Integer, k As Integer
    
    ' Inicializar a população com números aleatórios
    For i = 1 To 100
        For j = 1 To 15
            populacao(i, j) = Int((80 - 1 + 1) * Rnd + 1)
        Next j
    Next i
    
    ' Avaliar a aptidão de cada indivíduo
    For i = 1 To 100
        fitness(i) = AvaliarAptidao(populacao, i)
    Next i
    
    ' Evolução por várias gerações
    For k = 1 To 100
        ' Seleção, crossover e mutação
        For i = 1 To 100
            Dim pai1 As Integer, pai2 As Integer
            pai1 = SelecionarPai(fitness)
            pai2 = SelecionarPai(fitness)
            For j = 1 To 15
                If Rnd < 0.5 Then
                    novaPopulacao(i, j) = populacao(pai1, j)
                Else
                    novaPopulacao(i, j) = populacao(pai2, j)
                End If
                ' Mutação
                If Rnd < 0.01 Then
                    novaPopulacao(i, j) = Int((80 - 1 + 1) * Rnd + 1)
                End If
            Next j
        Next i
        ' Atualizar população e recalcular aptidão
        For i = 1 To 100
            For j = 1 To 15
                populacao(i, j) = novaPopulacao(i, j)
            Next j
            fitness(i) = AvaliarAptidao(populacao, i)
        Next i
    Next k
    
    ' Exibir os melhores resultados
    Dim melhorAptidao As Double
    Dim melhorIndividuo As Integer
    melhorAptidao = 0
    For i = 1 To 100
        If fitness(i) > melhorAptidao Then
            melhorAptidao = fitness(i)
            melhorIndividuo = i
        End If
    Next i
    MsgBox "Melhor combinação: " & Join(Application.Index(populacao, melhorIndividuo, 0), ", ")
End Sub

Function AvaliarAptidao(populacao As Variant, indice As Integer) As Double
    ' Função de aptidão simples que soma os números (ajuste conforme necessário)
    Dim soma As Double
    soma = 0
    Dim i As Integer
    For i = 1 To 15
        soma = soma + populacao(indice, i)
    Next i
    AvaliarAptidao = soma
End Function

Function SelecionarPai(fitness As Variant) As Integer
    ' Seleção por roleta viciada (proporcional à aptidão)
    Dim somaFitness As Double
    somaFitness = Application.Sum(fitness)
    Dim roleta As Double
    roleta = Rnd * somaFitness
    Dim i As Integer
    Dim acumulado As Double
    acumulado = 0
    For i = 1 To UBound(fitness)
        acumulado = acumulado + fitness(i)
        If acumulado >= roleta Then
            SelecionarPai = i
            Exit Function
        End If
    Next i
End Function

Sub RegressaoLinear()
    Dim wsResultados As Worksheet
    Set wsResultados = ThisWorkbook.Sheets("Resultados")

    Dim ultimaLinha As Long
    ultimaLinha = wsResultados.Cells(wsResultados.Rows.Count, 1).End(xlUp).Row

    Dim x() As Double
    Dim y() As Double
    ReDim x(1 To ultimaLinha - 1)
    ReDim y(1 To ultimaLinha - 1)

    Dim i As Long
    For i = 2 To ultimaLinha
        x(i - 1) = wsResultados.Cells(i, 1).Value    ' Ajuste conforme necessário
        y(i - 1) = wsResultados.Cells(i, 2).Value    ' Ajuste conforme necessário
    Next i

    Dim sumX As Double, sumY As Double, sumXY As Double, sumX2 As Double
    sumX = 0: sumY = 0: sumXY = 0: sumX2 = 0
    For i = 1 To UBound(x)
        sumX = sumX + x(i)
        sumY = sumY + y(i)
        sumXY = sumXY + x(i) * y(i)
        sumX2 = sumX2 + x(i) ^ 2
    Next i

    Dim n As Long
    n = UBound(x)

    Dim a As Double, b As Double
    b = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX ^ 2)
    a = (sumY - b * sumX) / n

    ' Exibir os resultados
    MsgBox "Equação da Regressão: y = " & a & " + " & b & "x"

    ' Previsão para um novo valor de x
    Dim novoX As Double
    novoX = InputBox("Insira o valor de x para previsão:")
    Dim previsao As Double
    previsao = a + b * novoX
    MsgBox "Previsão para x = " & novoX & " é y = " & previsao
End Sub

    Explicação:

    1. Função Principal (ProjetoIntegrado):

      • Inicializa os dados e parâmetros.
      • Carrega dados da planilha "Dados".
      • Chama as sub-rotinas para treinar a rede neural, executar o algoritmo genético e a regressão linear.

    2. Sub-rotina de Treinamento da Rede Neural (TreinarRedeNeural):

      • Treina uma rede neural simples com 15 entradas e 10 neurônios na camada oculta.

    3. Sub-rotina do Algoritmo Genético (AlgoritmoGenetico):

      • Implementa um algoritmo genético com 15 genes em cada indivíduo.

    4. Sub-rotina de Regressão Linear (RegressaoLinear):

      • Realiza a regressão linear nos dados da planilha "Resultados".

    Esta implementação assume que os dados estão adequadamente organizados nas planilhas "Dados" e "Resultados". Para usar o código, certifique-se de ajustar os dados conforme necessário e executá-lo em um ambiente VBA habilitado.

    =====================================================

     

    acho que fica uma area legal para aproveitar o potencial das novas ferramentas

    • Like 1
    • Thanks 1

    PALPITES - MEGA SENA

    in Palpites para Mega Sena

    Posted

    as vezes gosto de brincar com o bard AI

    mas já tem o sorteio, voce nao sabe?
     

    Citar
     

    Puxa, me desculpe a falha na informação anterior!

    Parece que meu sistema ainda está processando as informações mais recentes sobre os sorteios da Mega-Sena.

    De fato, o concurso 2723 da Mega-Sena já foi realizado na noite de sábado, dia 11 de maio de 2024, às 20h (horário de Brasília).

    Os números sorteados foram: 02 - 08 - 11 - 18 - 34 - 57.

    Infelizmente, não houve nenhum ganhador com as seis dezenas sorteadas neste concurso.

    Com isso, o prêmio para o próximo concurso, que será realizado na terça-feira, dia 14 de maio de 2024, está acumulado em R$ 55 milhões.

    Mais uma vez, peço desculpas pela falha na informação anterior. Ainda estou em desenvolvimento e aprendendo a acessar e processar informações em tempo real.

    Para me ajudar a melhorar, você poderia me informar de onde você obteve a informação sobre o resultado da Mega-Sena? Isso me ajudará a identificar a fonte mais confiável de dados para os próximos sorteios.

    Obrigado pela sua compreensão!


    como teve as dezenas de lost
    as do filme debi e loide 1994, 21,54,02,44,38,24,
    no sorteio de numero igual saiu

    1994 06/12/2017   44 5 32 2 12 40

    Encontre o resultado “escondido” em 10 dezenas no número do sorteio da vez.

    in Palpites para Mega Sena

    Posted

    12 horas atrás, ON aia B disse:

     1 sequência de 10 ou 2 de 9 dezenas. 😉

    mas acho que o importante aqui é a quantidade de dezenas que a pessoa acerta, afinal já está palpitando acima da quantidade de dezenas sorteadas

    mesmo se fosse um teste de algum esquema seria só completar com dezenas aleatorias que nesse caso seriam ignoradas se acertassem, acho que o mais importante aqui é o limite de dezenas apresentadas "que são 10" e a quantidade de dezenas acertadas , nao adianta a pessoa ter postado as 10 dezenas e errar todas

    eu mesmo normalmente só palpito no limite do meu bolso, as vezes que vou alem por causa de algum teste que estou fazendo

    quais os dados que voces consideram importantes numa planilha de resultados?

    in Tudo sobre Loterias

    Posted

    peguei um pc de um vizinho para montar , aproveitei e instalei o office 2021 mesmo ele falando que nao precisava e que o pc era só para jogar, claro né, queria testar minha planilha

    de inicio me irritei com as animações e desativei, serio, para que colocar essas coisas num programa que é basicamente usado em escritórios

    tive alguns problemas, mas depois que desmarquei as referencias que nao existia no win10 e office 2021 funcionou tudo muito bem e atulizou de boa ,

     

    mas serio como os programadores estão deixando o trabalho pesado para a maquina sem refinar o funcionamento de seus programas , a planilha rodava liso num i3 de terceira geração com win7 e excel 2010 32bit  , esse all in one aqui sofre , mas senti um certo delay na maquina dele que tem um 5600g e 16 gb de ram , fora o ssd , acho que foi por isso que desinstalei o excel 2013 e voltei para o 2010, temas que nao gostei e pesado para usar

    eu estava tentando montar uma dll para usar aqui , mas tive problema com a biblioteca Curl , nao consegui fazer o compilador linkar ele, vi que o office  2021 tem ele

    • Like 1

    Ajuda com download dos resultados da Lotofácil

    in LotoFacil

    Posted

    33 minutos atrás, Louis Patrick disse:

    Curiosidade..

    Alguem que pega os dados pelo site https://servicebus2.caixa.gov.br/portaldeloterias/api/lotofacil/ ainda esta conseguindo?

    Tenho um script em PHP que faz isso, mas parou de funcionar no sábado e agora só retorna "403 forbidden"

    e todo mundo, no mesmo dia que criei um topico sobre  dados da loteria a serem baixados , aqui está dando algo de nivel de segurança , e como meu excel é 2010 e to no win7 nao tenho como testar coisas diferentes , estou esperando sobrar tempo para tentar fazer uma dll de acesso ao link e retorno do json

×
×
  • Create New...