Surpresinha Direcionada e Rede Neural (Python)

[BigMax]

Trabalho do ChatGPT e postagem minha.
O script abaixo, gera números aleatórios direcionado a Megasena ( originalmente - pode ser alterado para outras loterias ), obedecendo faixas de parâmetros:
# Defina as faixas de parâmetros
faixa1 = [4, 14]
faixa2 = [15, 22]
faixa3 = [23, 31]
faixa4 = [32, 40]
faixa5 = [41, 49]
faixa6 = [50, 58]

Acho que é melhor assim que as surpresinhas da CEF.
 

import random

def gerar_linhas(quantidade_linhas, quantidade_numeros, faixas):
    linhas = []

    for _ in range(quantidade_linhas):
        linha = []
        for i in range(quantidade_numeros):
            faixa_atual = faixas[i]
            numero_gerado = random.randint(faixa_atual[0], faixa_atual[1])
            linha.append(numero_gerado)
        linha.sort()
        linhas.append(linha)

    return linhas

# Pergunta quantas linhas o usuário deseja gerar
quantidade_linhas = int(input("Digite a quantidade de linhas a serem geradas: "))
quantidade_numeros = 6  # Você pode ajustar o número de números por linha se quiser

# Defina as faixas de parâmetrosfaixa1 = [4, 14]

faixa1 = [4, 14]

faixa2 = [15, 22]
faixa3 = [23, 31]
faixa4 = [32, 40]
faixa5 = [41, 49]
faixa6 = [50, 58]

faixas = [faixa1, faixa2, faixa3, faixa4, faixa5, faixa6]

# Gere as linhas
linhas = gerar_linhas(quantidade_linhas, quantidade_numeros, faixas)

# Imprima as linhas não ordenadas
print("\nLinhas geradas:")
for linha in linhas:
    print(linha)

# Ordene as linhas
linhas.sort()

# Abra um arquivo de relatório para escrita
with open("relatorio.txt", "w") as relatorio:
    # Escreva o relatório de saída no arquivo
    for linha in linhas:
        relatorio.write(" ".join([str(numero).zfill(2) for numero in linha]) + "\n")

print("Relatório gerado com sucesso no arquivo 'relatorio.txt'.")

Edited January 20 by BigMax
correção parâmetros faixas

[Rany]

Existe um pequeno erro no seu exemplo, utilizando da forma apresentada, pode acontecer que a faixa 2 seja igual a faixa 1 e assim por diante. Neste caso teria que ajustar as faixas para não coincidir ou fazer uma comparação entre as faixas, caso seja igual gere novamente.

 

Saudações!!!

[BigMax]

1 hora atrás, Rany disse:

Existe um pequeno erro no seu exemplo, utilizando da forma apresentada, pode acontecer que a faixa 2 seja igual a faixa 1 e assim por diante. Neste caso teria que ajustar as faixas para não coincidir ou fazer uma comparação entre as faixas, caso seja igual gere novamente.

 

Saudações!!!

Feito as correções sugeridas.
Obrigado!

[BigMax]

Citar

@Rany @DixieJoe @sorel

E outros...

Pessoal, sou meio "burrão", fiz só até a 5ª série e não tenho competência para isso ( Embrulha pra viagem - youtube). Quem fez foi Chatgpt e eu estou publicando aqui. Deu um trabalhão danado para um leigo em programação "ensinar" a IA o que eu queria. 
Evidente que essa rede neural é simples, é apenas um aprendizado "na marra" ( ao invés de ler livros e fazer curso, vamos por ensaio e erro ).

O que ela faz?
Seleciona alguns concursos passados que entende com potencial maior de ter números a serem sorteados e emite um listagem denominado predicão nesse formato: 
15: 20, 32, 34, 49, 58, 60
51: 15, 30, 38, 46, 58, 59
107: 21, 24, 29, 34, 59, 60
147: 32, 35, 41, 55, 58, 59
e outra listagem com os 25 números mais frequentes na  "predicao" nesse formato:
59 => 37 x
60 => 35 x
58 => 33 x
57 => 11 x
20 => 7 x
47 => 7 x
16 => 7 x
50 => 7 x
22 => 6 x
42 => 6 x

Se realmente tem aplicação prática, só testando e amanhã veremos. Se tem erros, eu não sei. Por favor, quem puder apontar erros colocar novas camadas etc... o espaço é público.
E vamos que vamos... eu ainda chego lá. ( no sentido de fazer a 6ª série KKKKK)
////////////////////////////////////
 

import numpy as np
from collections import Counter
class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size, learning_rate=0.01, epochs=2861):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.learning_rate = learning_rate
        self.epochs = epochs

        # Inicialização dos pesos e vieses
        self.weights_input_hidden = np.random.randn(self.input_size, self.hidden_size)
        self.bias_hidden = np.zeros((1, self.hidden_size))
        self.weights_hidden_output = np.random.randn(self.hidden_size, self.output_size)
        self.bias_output = np.zeros((1, self.output_size))

    def sigmoid(self, x):
        # Evitar overflow usando a função clip
        x = np.clip(x, -500, 500)
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def forward(self, X):
        # Propagação direta
        self.hidden_activation = self.sigmoid(np.dot(X, self.weights_input_hidden) + self.bias_hidden)
        self.output = self.sigmoid(np.dot(self.hidden_activation, self.weights_hidden_output) + self.bias_output)
        return self.output

    def backward(self, X, y):
        # Retropropagação
        output_error = y - self.output
        output_delta = output_error * self.sigmoid_derivative(self.output)

        hidden_error = output_delta.dot(self.weights_hidden_output.T)
        hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden_activation)

        # Atualização dos pesos e vieses (faltava no código original)
        self.weights_hidden_output += self.hidden_activation.T.dot(output_delta) * self.learning_rate
        self.bias_output += np.sum(output_delta, axis=0, keepdims=True) * self.learning_rate
        self.weights_input_hidden += X.T.dot(hidden_delta) * self.learning_rate
        self.bias_hidden += np.sum(hidden_delta, axis=0, keepdims=True) * self.learning_rate

    def train(self, X, y):
        for epoch in range(self.epochs):
            # Propagação e retropropagação
            self.forward(X)
            self.backward(X, y)

# Função para carregar dados de um arquivo TXT e normalizar
def load_data(file_path):
    data = np.loadtxt(file_path, dtype=np.float32)
    # Normalização para valores entre 0 e 1
    normalized_data = (data - np.min(data, axis=0)) / (np.max(data, axis=0) - np.min(data, axis=0))
    # Última coluna é considerada como saída, o restante como entrada
    X = normalized_data[:, :-1]
    y = normalized_data[:, -1].reshape(-1, 1)
    return X, y

# Exemplo de uso
# Leia os dados do arquivo txt
# Leia os dados do arquivo txt
file_path = "dados.txt"
X, y = load_data(file_path)

# Crie uma instância da rede neural
input_size = X.shape[1]
hidden_size = 4
output_size = 1
learning_rate = 0.01  # Reduzi a taxa de aprendizado
epochs = 2681

nn = NeuralNetwork(input_size, hidden_size, output_size, learning_rate, epochs)

# Treine a rede
nn.train(X, y)

# Fazendo previsões
predictions = nn.forward(X)
print("Predictions:")
print(predictions)

# Arredondando as previsões para os números inteiros mais próximos
rounded_predictions = np.round(predictions, decimals=1).astype(int)

print("Rounded Predictions:")
print(list(enumerate(rounded_predictions)))
print('*'*30)
lista_oficial = []

# Carregando os dados originais sem normalização
data_original = np.loadtxt(file_path, dtype=np.float32)

for lin, pred in zip(enumerate(predictions), rounded_predictions):
    print(lin)
    if pred > 0.95:
        linha_com_seis_numeros = data_original[lin[0]].astype(int)
        lista_oficial.append((lin[0], linha_com_seis_numeros))
        with open('predicao.txt', 'a') as final:
            final.write(f"{lin[0]}: {', '.join(map(str, linha_com_seis_numeros))}\n")

print(len(lista_oficial))
print('$'*50)
for k in lista_oficial:
    print(k)
    # Contagem de frequência e geração de relatório
numeros_predicoes = []

# Leia as linhas relacionadas às predições
for lin, pred in zip(enumerate(predictions), rounded_predictions):
    if pred > 0.95:
        linha_com_seis_numeros = data_original[lin[0]].astype(int)
        numeros_predicoes.extend(linha_com_seis_numeros)

# Crie um dicionário para armazenar a contagem de cada número
contagem = Counter(numeros_predicoes)

# Obtenha os 25 números com maior frequência
top_25_numbers = contagem.most_common(25)

# Abra um arquivo de relatório para escrita
with open("relatorio.txt", "w") as relatorio:
    # Escreva o relatório de saída no arquivo
    for numero, quantidade in top_25_numbers:
        relatorio.write(f"{numero} => {quantidade} x\n")

print("Relatório gerado com sucesso no arquivo 'relatorio.txt'.")

[BigMax]

Observação: o arquivo inicial da rede neural são os resultados da Megasena.
Arquivo extensão .txt. com o nome dados.