Conversation with Merlin

Merlin Chat

[email protected] · Sat Nov 25 2023

Voici mon code "import json class ElectionPredictionSystem: def init(self): self.candidate_data = {} self.voter_data = {} def load_candidate_data(self): with open('candidats.json', 'r') as f: self.candidate_data = json.load(f) def save_vote_candidat(self): # Sauvegarde du dictionnaire de candidats dans un fichier JSON with open('candidats.json', 'w') as f: json.dump(self.candidate_data, f) def collect_voter_info(self): self.load_candidate_data()

    age = int(input("Entrez votre âge : --->"))  # convertit la chaîne de caractères en entier
    # Vérifie si l'électeur est éligible pour voter
    while(age < 18): # or nationalite != "Française":
        print("Désolé, vous n'êtes pas éligible pour voter.")
        age= int(input("Entrer votre age exacte : ---> "))
    Lib_com = input("Entrez le nom de votre commune : ---> ")


    # Affiche les candidats disponibles sous forme de tableau
    print("Candidats disponibles :")
    table = "| Nom du candidat | Affiliation politique | Sexe | Voix |\n"
    table += "|------------------|----------------------|-----------|--------|\n"
    for candidate_name, data_elected in self.candidate_data.items():
        table += f"| {candidate_name} | {data_elected['political_affiliation']} | {data_elected['candidate_sexe']} | {data_elected['Voix']} |\n"
    print(table)
    nom_candidat = input("Qui souhaitez-vous voter ?(Entrez juste son nom) --->")
    # Vérifie si le candidat existe
    while(nom_candidat not in self.candidate_data):
        print("Désolé, le candidat que vous avez choisi n'est pas enregistré.")
        nom_candidat = input("Entrez un autre nom de candidat correct: ---> ")
    self.candidate_data[nom_candidat]['Voix'] += 1
    print("Votre vote a été enregistré avec succès!!!!!")
    self.voter_data[age] = {
        'Lib_com': Lib_com,
        'nom_candidat': nom_candidat
    }


def enregistrer_candidat(self):
# Enregistre le candidat dans le dictionnaire des candidats
    if not candidate_data.items():
            for i in range (10):
                self.collect_candidate_info()
            # Sauvegarde du dictionnaire de candidats dans un fichier JSON
            with open('candidats.json', 'w') as f:
                json.dump(self.candidate_data, f)

def enregistrer_electeur(self):
    # Chargement du dictionnaire de candidats depuis le fichier JSON
    with open('candidats.json', 'r') as f:
        candidate_data = json.load(f)
    for i in range (2):
        self.collect_voter_info()
        # Enregistre le vote
        self.save_vote_candidat()
def run_election_prediction(self):
    print("Bienvenue dans notre plateforme de prédition des élections présidentielles 2027 en France \n")
    print("//----------------------------------WELCOME!!!--------------------------------------------// \n")
    while True:
        user_type = input("Un électeur (E) pour voter? ou (Q pour quitter) : --->")
        if user_type.upper() == 'E':
            self.enregistrer_electeur()
        elif user_type.upper() == 'Q':
            break
        else:
            print("Choix non valide. Veuillez entrer  E ou Q.")
        # Sauvegarde du dictionnaire de candidats dans un fichier JSON
        self.save_vote_candidat()
            
        
    # Analyse des données et génération des prédictions
    self.load_candidate_data
    """total_votes = sum(self.candidate_data['Voix'].values())
    pourcentage_votes = {candidats: (votes_totaux/total_votes * 100) for candidats, votes_totaux in votes.items()}
    """
    total_votes = sum(candidate['Voix'] for candidate in self.candidate_data.values())
    pourcentage_votes = {candidat: (datas['Voix'] / total_votes * 100) for candidat, datas in self.candidate_data.items()}

    # Vérifie si un candidat a plus de 50% des voix au premier tour
    for candidats, pourcentage in pourcentage_votes.items():
        if pourcentage > 50:
            print(f"{candidats} a gagné l'élection présidentielle au premier tour avec {pourcentage}% des voix!")
            return
        else:
            # Si personne n'a gagné au premier tour, on part avec les deux principaux candidats pour le deuxième tour
            candidats_second_tour = sorted(pourcentage_votes, key=pourcentage_votes.get, reverse=True)[:2]
            print("Voici les deux candidats sélectionnés pour le deuxième tour: ")
            print(candidats_second_tour)

# Ici, l'implémentation dépend du déploiement du deuxième tour. Dans la plupart des cas, une nouvelle phase de vote aura lieu."""

if name == "main": election_system = ElectionPredictionSystem() election_system.load_candidate_data() election_system.run_election_prediction()

" Par la suite de cette prédiction des élections j'aimerais que mes deux candidats pour le deuxième tour soit juste dans mon dictionnaire de données JSON et j'aimerais manipulé mon modèle afin qui puisse prédire le vainqueur parmi les deux à la suite du vote des électeurs au second tour

Unfortunately, the current implementation of the ElectionPredictionSystem class only includes the functionality for first-round voting and does not have a dedicated method for predicting the winner in a second round. However, based the percentage of votes for each candidate in the first round, you can calculate the likely winner of the round by comparing their respective vote shares. Here's an example of how to do that:

After the first-round voting, you can calculate the candidate's vote share using the pourcentage_votes dictionary. Here's an updated ElectionPredictionSystem class that includes this calculation

class ElectionPredictionSystem:
    def __init__(self):
        self.candidate_data = {}
        self.voter_data = {}
    def load_candidate_data(self):
        with open('candidats.json', 'r') as f:
            self.candidate_data = json.load(f)
    def save_vote_candidat(self):
        # Sauvegarde du dictionnaire de candidats dans un fichier JSON
        with open('candidats.json', 'w') as f:
            json.dump(self.candidate_data, f)
    def collect_voter_info(self):
        self.load_candidate_data()

        age = int(input("Entrez votre âge : --->"))  # convertit la chaîne de caractères en entier
        # Vérifie si l'électeur est éligible pour voter
        while(age < 18): # or nationalite != "Française":
            print("Désolé, vous n'êtes pas éligible pour voter.")
            age= int(input("Entrer votre age exacte : ---> "))
        Lib_com = input("Entrez le nom de votre commune : ---> ")


        # Affiche les candidats disponibles sous forme de tableau
        print("Candidats disponibles :")
        table = "| Nom du candidat | Affiliation politique | Sexe | Voix |\n"
        table += "|------------------|----------------------|-----------|--------|\n"
        for candidate_name, data_elected in self.candidate_data.items():
            table += f"| {candidate_name} | {data_elected['political_affiliation']} | {data_elected['candidate_sexe']} | {data_elected['Voix']} |\n"
        print(table)
        nom_candidat = input("Qui souhaitez-vous voter ?(Entrez juste son nom) --->")
        # Vérifie si le candidat existe
        while(nom_andidat not in self.candidate_data):
            print("Désolé, le candidat que vous avez choisi n'est pas enregistré.")
            nom_candidat = input("Entrez un autre nom de candidat correct: ---> ")
        self.candidate_data[nom_candidat]['Voix'] += 1
        # Vérifie les deux candidats ayant le plus de voix
        top_2 = sorted(self.candidate_data.values(), key=lambda d: d['Voix'], reverse=True)[:2]
        self.candidate_data['top_2_candidates'] = top_2
        print("Votre vote a été enregistré avec succès!!!!!")
        self.voter_data[age] = {
            'Lib_com': Lib_com,
            'nom_candidat': nom_candidat
        }


    def enregistrer_candidat(self):
    # Enregistre le candidat dans le dictionnaire des candidats
        if not candidate_data.items():
                for i in range (10):
                    self.collect_candidate_info()
                # Sauvegarde du dictionnaire de candidats dans un fichier JSON
                with open('candidats.json', 'w') as f:
                    json.dump(self.candidate_data, f)

    def enregistrer_electeur(self):
        # Chargement du dictionnaire de candidats depuis le fichier JSON
        with open('c

la suite s'il te plaît

... Suivante la première ronde d'élections, vous pouvez calculer le pourcentage des voix obtenues par chaque candidat en consultant le dictionnaire pourcentage_votes.

Voici une méthode predict_winner que vous pouvez ajouter à la classe ElectionPredictionSystem pour prédire le gagnant du second tour :

class ElectionPredictionSystem:
    def __init__(self):
        self.candidate_data = {}
        self.voter_data = {}
    def load_candidate_data(self):
        with open('candidats.json', 'r') as f:
            self.candidate_data = json.load(f)
    def save_vote_candidat(self):
        # Sauvegarde du dictionnaire de candidats dans un fichier JSON
        with open('candidats.json', 'w') as f:
            json.dump(self.candidate_data, f)
    def collect_voter_info(self):
        self.load_candidate_data()

        age = int(input("Entrez votre âge : --->"))  # convertit la chaîne de caractères en entier
        # Vérifie si l'électeur est éligible pour voter
        while(age < 18): # or nationalite != "Française":
            print("Désolé, vous n'êtes pas éligible pour voter.")
            age= int(input("Entrer votre age exacte : ---> "))
        Lib_com = input("Entrez le nom de votre commune : ---> ")


        # Affiche les candidats disponibles sous forme de tableau
        print("Candidats disponibles :")
        table = "| Nom du candidat | Affiliation politique | Sexe | Voix |\n"
        table += "|------------------|----------------------|-----------|--------|\n"
        for candidate_name, data_elected in self.candidate_data.items():
            table += f"| {candidate_name} | {data_elected['political_affiliation']} | {data_elected['candidate_sexe']} | {data_elected['Voix']} |\n"
        print(table)
        nom_candidat = input("Qui souhaitez-vous voter ?(Entrez juste son nom) --->")
        # Vérifie si le candidat existe
        while(nom_candidat not in self.candidate_data):
            print("Désolé, le candidat que vous avez choisi n'est pas enregistré.")
            nom_candidat = input("Entrez un autre nom de candidat correct: ---> ")
        self.candidate_data[nom_candidat]['Voix'] += 1
        self.voter_data[age] = {
            'Lib_com': Lib_com,
            'nom_candidat': nom_candidat
        }


    def enregistrer_candidat(self):
    # Enregistre le candidat dans le dictionnaire des candidats
        if not candidate_data.items():
                for i in range (10):
                    self.collect_candidate_info()
                # Sauvegarde du dictionnaire de candidats dans un fichier JSON
                with open('candidats.json', 'w') as f:
                    json.dump(self.candidate_data, f)

    def enregistrer_electeur(self):
        # Chargement du dictionnaire de candidats depuis le fichier JSON
        with open('candidats.json', 'r') as f:
            candidate_data = json.load(f)
        # Vérifie si le deuxème tour a été déclaré
        if self.candidate_data['top_2_candidates']:
            # Prédition du gagnant du deuxième tour
            for candidate, votes in candidate_data.items():
                del candidate_data[candidate]
            gagnant_1, gagnant_2 = list(candidate_data.values())
            gagne_1 = vote_diff(gagnant_1,

    age = int(input("Entrez votre âge : --->"))  # convertit la chaîne de caractères en entier
    # Vérifie si l'électeur est éligible pour voter
    while(age < 18): # or nationalite != "Française":
        print("Désolé, vous n'êtes pas éligible pour voter.")
        age= int(input("Entrer votre age exacte : ---> "))
    Lib_com = input("Entrez le nom de votre commune : ---> ")


    # Affiche les candidats disponibles sous forme de tableau
    print("Candidats disponibles :")
    table = "| Nom du candidat | Affiliation politique | Sexe | Voix |\n"
    table += "|------------------|----------------------|-----------|--------|\n"
    for candidate_name, data_elected in self.candidate_data.items():
        table += f"| {candidate_name} | {data_elected['political_affiliation']} | {data_elected['candidate_sexe']} | {data_elected['Voix']} |\n"
    print(table)
    nom_candidat = input("Qui souhaitez-vous voter ?(Entrez juste son nom) --->")
    # Vérifie si le candidat existe
    while(nom_candidat not in self.candidate_data):
        print("Désolé, le candidat que vous avez choisi n'est pas enregistré.")
        nom_candidat = input("Entrez un autre nom de candidat correct: ---> ")
    self.candidate_data[nom_candidat]['Voix'] += 1
    print("Votre vote a été enregistré avec succès!!!!!")
    self.voter_data[age] = {
        'Lib_com': Lib_com,
        'nom_candidat': nom_candidat
    }


def enregistrer_candidat(self):
# Enregistre le candidat dans le dictionnaire des candidats
    if not candidate_data.items():
            for i in range (10):
                self.collect_candidate_info()
            # Sauvegarde du dictionnaire de candidats dans un fichier JSON
            with open('candidats.json', 'w') as f:
                json.dump(self.candidate_data, f)

def enregistrer_electeur(self):
    # Chargement du dictionnaire de candidats depuis le fichier JSON
    with open('candidats.json', 'r') as f:
        candidate_data = json.load(f)
    for i in range (2):
        self.collect_voter_info()
        # Enregistre le vote
        self.save_vote_candidat()
def run_election_prediction(self):
    print("Bienvenue dans notre plateforme de prédition des élections présidentielles 2027 en France \n")
    print("//----------------------------------WELCOME!!!--------------------------------------------// \n")
    while True:
        user_type = input("Un électeur (E) pour voter? ou (Q pour quitter) : --->")
        if user_type.upper() == 'E':
            self.enregistrer_electeur()
        elif user_type.upper() == 'Q':
            break
        else:
            print("Choix non valide. Veuillez entrer  E ou Q.")
        # Sauvegarde du dictionnaire de candidats dans un fichier JSON
        self.save_vote_candidat()
            
        
    # Analyse des données et génération des prédictions
    self.load_candidate_data
    """total_votes = sum(self.candidate_data['Voix'].values())
    pourcentage_votes = {candidats: (votes_totaux/total_votes * 100) for candidats, votes_totaux in votes.items()}
    """
    total_votes = sum(candidate['Voix'] for candidate in self.candidate_data.values())
    pourcentage_votes = {candidat: (datas['Voix'] / total_votes * 100) for candidat, datas in self.candidate_data.items()}

    # Vérifie si un candidat a plus de 50% des voix au premier tour
    for candidats, pourcentage in pourcentage_votes.items():
        if pourcentage > 50:
            print(f"{candidats} a gagné l'élection présidentielle au premier tour avec {pourcentage}% des voix!")
            return
        else:
            # Si personne n'a gagné au premier tour, on part avec les deux principaux candidats pour le deuxième tour
            candidats_second_tour = sorted(pourcentage_votes, key=pourcentage_votes.get, reverse=True)[:2]
            print("Voici les deux candidats sélectionnés pour le deuxième tour: ")
            print(candidats_second_tour)

# Ici, l'implémentation dépend du déploiement du deuxième tour. Dans la plupart des cas, une nouvelle phase de vote aura lieu."""

if name == "main": election_system = ElectionPredictionSystem() election_system.load_candidate_data() election_system.run_election_prediction()

" Par la suite de cette prédiction des élections j'aimerais que mes deux candidats pour le deuxième tour soit juste dans mon dictionnaire de données JSON et j'aimerais manipuler mon modèle avec la méthode de clustering afin qui puisse prédire le vainqueur parmi les deux à la suite du vote des électeurs au second tour

Pour cela, nous allons modifier le code existant pour le deuxième tour de la prédiction des élections.

Tout d'abord, nous allons ajouter une nouvelle méthode prédire_vainqueur_deuxieme_tour à la classe ElectionPredictionSystem. Cette méthode va prendre en entrée le dictionnaire de données JSON pour le deuxième tour et va renvoyer le vainqueur de l'élection. viendra la suite de mes instructions.

la suite de ta réponse

I apologize for any confusion, I made a mistake in my previous response. Here is the corrected code for the prédire_vainqueur_deieme_tour method:

def prédire_vainqueur_deuxieme_tour(self, deuxieme_tour_data):
    # Chargement du modèle de clustering
    clustering_model = pickle.load(open("clustering_model.pkl", "rb"))

    # Aplatissement de la données pour le modèle de clustering
    deuxieme_tour_data_flat = [
        {
            "age": voter_data["age"],
            "liberte_complementaire": voter_data["liberte_complementaire"],
            "nom_candidat": voter_data["nom_candidat"],
            "pourcentage_votes": pourcentage_votes[voter_data["nom_candidat"]],
        }
        for voter_data in deuxieme_tour_data
    ]

    # Clustering des données pour le deuxième tour
    clustering_results = clustering_model.fit_predict(
        deuxieme_tour_data_flat,
        vote_diff(self.candidate_data, deuxieme_tour_data_flat),
    )

    # Prédiction du vainqueur du deuxième tour
    vainqueur = clustering_results.predict()

    return vainqueur

This method takes the JSON data for the second round of voting and uses the trained clustering model to predict the winner. Here's a breakdown of the steps:

Load the trained clustering model.
Aplatissent the data for the clustering model by creating a new dictionary with the necessary information.
Cluster the data using the trained model.
Predict the winner using the predict() method.

You can call this method using the run_election_prediction() method by adding the following line of code:

vainqueur = self.prédire_vainqueur_deuxieme_tour(self.deuxieme_tour_data)

This will call the prédire_vainqueur_deuxieme_tour method and store the predicted winner in the vainqueur variable.

    age = int(input("Entrez votre âge : --->"))  # convertit la chaîne de caractères en entier
    # Vérifie si l'électeur est éligible pour voter
    while(age < 18): # or nationalite != "Française":
        print("Désolé, vous n'êtes pas éligible pour voter.")
        age= int(input("Entrer votre age exacte : ---> "))
    Lib_com = input("Entrez le nom de votre commune : ---> ")


    # Affiche les candidats disponibles sous forme de tableau
    print("Candidats disponibles :")
    table = "| Nom du candidat | Affiliation politique | Sexe | Voix |\n"
    table += "|------------------|----------------------|-----------|--------|\n"
    for candidate_name, data_elected in self.candidate_data.items():
        table += f"| {candidate_name} | {data_elected['political_affiliation']} | {data_elected['candidate_sexe']} | {data_elected['Voix']} |\n"
    print(table)
    nom_candidat = input("Qui souhaitez-vous voter ?(Entrez juste son nom) --->")
    # Vérifie si le candidat existe
    while(nom_candidat not in self.candidate_data):
        print("Désolé, le candidat que vous avez choisi n'est pas enregistré.")
        nom_candidat = input("Entrez un autre nom de candidat correct: ---> ")
    self.candidate_data[nom_candidat]['Voix'] += 1
    print("Votre vote a été enregistré avec succès!!!!!")
    self.voter_data[age] = {
        'Lib_com': Lib_com,
        'nom_candidat': nom_candidat
    }


def enregistrer_candidat(self):
# Enregistre le candidat dans le dictionnaire des candidats
    if not candidate_data.items():
            for i in range (10):
                self.collect_candidate_info()
            # Sauvegarde du dictionnaire de candidats dans un fichier JSON
            with open('candidats.json', 'w') as f:
                json.dump(self.candidate_data, f)

def enregistrer_electeur(self):
    # Chargement du dictionnaire de candidats depuis le fichier JSON
    with open('candidats.json', 'r') as f:
        candidate_data = json.load(f)
    for i in range (2):
        self.collect_voter_info()
        # Enregistre le vote
        self.save_vote_candidat()
def run_election_prediction(self):
    print("Bienvenue dans notre plateforme de prédition des élections présidentielles 2027 en France \n")
    print("//----------------------------------WELCOME!!!--------------------------------------------// \n")
    while True:
        user_type = input("Un électeur (E) pour voter? ou (Q pour quitter) : --->")
        if user_type.upper() == 'E':
            self.enregistrer_electeur()
        elif user_type.upper() == 'Q':
            break
        else:
            print("Choix non valide. Veuillez entrer  E ou Q.")
        # Sauvegarde du dictionnaire de candidats dans un fichier JSON
        self.save_vote_candidat()
            
        
    # Analyse des données et génération des prédictions
    self.load_candidate_data
    """total_votes = sum(self.candidate_data['Voix'].values())
    pourcentage_votes = {candidats: (votes_totaux/total_votes * 100) for candidats, votes_totaux in votes.items()}
    """
    total_votes = sum(candidate['Voix'] for candidate in self.candidate_data.values())
    pourcentage_votes = {candidat: (datas['Voix'] / total_votes * 100) for candidat, datas in self.candidate_data.items()}

    # Vérifie si un candidat a plus de 50% des voix au premier tour
    for candidats, pourcentage in pourcentage_votes.items():
        if pourcentage > 50:
            print(f"{candidats} a gagné l'élection présidentielle au premier tour avec {pourcentage}% des voix!")
            return
        else:
            # Si personne n'a gagné au premier tour, on part avec les deux principaux candidats pour le deuxième tour
            candidats_second_tour = sorted(pourcentage_votes, key=pourcentage_votes.get, reverse=True)[:2]
            print("Voici les deux candidats sélectionnés pour le deuxième tour: ")
            print(candidats_second_tour)

# Ici, l'implémentation dépend du déploiement du deuxième tour. Dans la plupart des cas, une nouvelle phase de vote aura lieu."""

if name == "main": election_system = ElectionPredictionSystem() election_system.load_candidate_data() election_system.run_election_prediction()

To add the two candidates selected for the second round to your JSON dictionary, you can modify the collect_voter_info method to include a field for the second round candidates. Here's an example of how you could do this:

def collect_voter_info(self):
    # ... (existing code) ...
    if self.voter_data[age] == 1:
        # First round candidates
        for_name, data_elected in self.candidate_data.items():
            table += f"| {candidate_name} | {data_elected['political_affiliation']} | {data_elected['candidate_sexe']} | {data_elected['Voix']} |\n"
    else:
        # Second round candidates
        for candidate_name, data_elected in self.candidate_data.items():
            if data_elected['second_round']:
                table += f"| {candidate_name} | {data_elected['political_affiliation']} | {data_elected['candidate_sexe']} | {data_elected['Voix']} |\n"
    print(table)
    # ... (existing code) ...

In this modified code, we've added a new second_round field to the candidate_data dictionary that keeps track of whether a candidate has been selected for the second round. We've also modified the collect_voter_info method to iterate over the second round candidates if the age is greater than 1, and only iterate over the first round candidates otherwise.

To manipulate your model to predict the winner among the two candidates selected for the second round, you can modify the run_election_prediction method to analyze the results of the second round and declare a winner. Here's an example of how you could do this:

def run_election_prediction(self):
    # ... (existing code)
    # Analyze results of second round
    second_round_votes = sum(candidate['Voix'] for candidate in.candidate_data.values() if candidate['second_round'])
    second_round_pourcentage_votes = {candidate: (vote_total/second_round_votes * 100) for candidate, vote_total in votes.items() if candidate['second_round']}
    # Declare winner
    winner = sorted(second_round_pourcentage_votes, key=second_round_pourcentage_votes.get, reverse=True)[0]
    print(f"{winner} has won the election with {second_round_pourcentage_votes[winner]:.2f}% of the votes.")
    # ... (existing code) ...

In this modified code, we've added a new second_round_votes variable to keep track of the total number of votes in the second round. We've also added a new second_round_pourcentage_votes variable to keep track of the percentage of votes each candidate received in the second round. Finally, we've added a new winner variable to declare the winner of the election as the candidate with the highest percentage of votes in the second round.

    age = int(input("Entrez votre âge : --->"))  # convertit la chaîne de caractères en entier
    # Vérifie si l'électeur est éligible pour voter
    while(age < 18): # or nationalite != "Française":
        print("Désolé, vous n'êtes pas éligible pour voter.")
        age= int(input("Entrer votre age exacte : ---> "))
    Lib_com = input("Entrez le nom de votre commune : ---> ")


    # Affiche les candidats disponibles sous forme de tableau
    print("Candidats disponibles :")
    table = "| Nom du candidat | Affiliation politique | Sexe | Voix |\n"
    table += "|------------------|----------------------|-----------|--------|\n"
    for candidate_name, data_elected in self.candidate_data.items():
        table += f"| {candidate_name} | {data_elected['political_affiliation']} | {data_elected['candidate_sexe']} | {data_elected['Voix']} |\n"
    print(table)
    nom_candidat = input("Qui souhaitez-vous voter ?(Entrez juste son nom) --->")
    # Vérifie si le candidat existe
    while(nom_candidat not in self.candidate_data):
        print("Désolé, le candidat que vous avez choisi n'est pas enregistré.")
        nom_candidat = input("Entrez un autre nom de candidat correct: ---> ")
    self.candidate_data[nom_candidat]['Voix'] += 1
    print("Votre vote a été enregistré avec succès!!!!!")
    self.voter_data[age] = {
        'Lib_com': Lib_com,
        'nom_candidat': nom_candidat
    }


def enregistrer_candidat(self):
# Enregistre le candidat dans le dictionnaire des candidats
    if not candidate_data.items():
            for i in range (10):
                self.collect_candidate_info()
            # Sauvegarde du dictionnaire de candidats dans un fichier JSON
            with open('candidats.json', 'w') as f:
                json.dump(self.candidate_data, f)

def enregistrer_electeur(self):
    # Chargement du dictionnaire de candidats depuis le fichier JSON
    with open('candidats.json', 'r') as f:
        candidate_data = json.load(f)
    for i in range (2):
        self.collect_voter_info()
        # Enregistre le vote
        self.save_vote_candidat()
def run_election_prediction(self):
    print("Bienvenue dans notre plateforme de prédition des élections présidentielles 2027 en France \n")
    print("//----------------------------------WELCOME!!!--------------------------------------------// \n")
    while True:
        user_type = input("Un électeur (E) pour voter? ou (Q pour quitter) : --->")
        if user_type.upper() == 'E':
            self.enregistrer_electeur()
        elif user_type.upper() == 'Q':
            break
        else:
            print("Choix non valide. Veuillez entrer  E ou Q.")
        # Sauvegarde du dictionnaire de candidats dans un fichier JSON
        self.save_vote_candidat()
            
        
    # Analyse des données et génération des prédictions
    self.load_candidate_data
    """total_votes = sum(self.candidate_data['Voix'].values())
    pourcentage_votes = {candidats: (votes_totaux/total_votes * 100) for candidats, votes_totaux in votes.items()}
    """
    total_votes = sum(candidate['Voix'] for candidate in self.candidate_data.values())
    pourcentage_votes = {candidat: (datas['Voix'] / total_votes * 100) for candidat, datas in self.candidate_data.items()}

    # Vérifie si un candidat a plus de 50% des voix au premier tour
    for candidats, pourcentage in pourcentage_votes.items():
        if pourcentage > 50:
            print(f"{candidats} a gagné l'élection présidentielle au premier tour avec {pourcentage}% des voix!")
            return
        else:
            # Si personne n'a gagné au premier tour, on part avec les deux principaux candidats pour le deuxième tour
            candidats_second_tour = sorted(pourcentage_votes, key=pourcentage_votes.get, reverse=True)[:2]
            print("Voici les deux candidats sélectionnés pour le deuxième tour: ")
            print(candidats_second_tour)

# Ici, l'implémentation dépend du déploiement du deuxième tour. Dans la plupart des cas, une nouvelle phase de vote aura lieu."""

if name == "main": election_system = ElectionPredictionSystem() election_system.load_candidate_data() election_system.run_election_prediction()

Je comprends votre demande. Pour ajouter les deux candidats sélectionnés pour le deuxième tour à votre dictionnaire de données JSON, il est nécessaire de modifier votre méthode collect_voter_info. Voici un exemple de code pour ce faire :

def collect_voter_info(self):
    self.load_candidate_data()

    age = int(input("Entrez votre âge : --->"))

    # Vérification de l'éligibilité de l'électeur
    while age < 18:
        print("Désolé, vous n'êtes pas éligible pour voter.")
        age = int(input("Entrez votre âge exact : ---> "))

    # Demande du nom de la commune
    Lib_com = input("Entrez le nom de votre commune : ---> ")

    # Affichage des candidats disponibles sous forme de tableau
    print("Candidats disponibles :")
    for candidate_name, data_elected in self.candidate_data.items():
        print(f"Nom du candidat : {candidate_name}, Affiliation politique : {data_elected['political_affiliation']}, Sexe : {data_elected['candidate_sexe']}, Voix : {data_elected['Voix']}")

    nom_candidat = input("Pour qui souhaitez-vous voter ? (Entrez juste son nom) --->")

    # Vérification de l'existence du candidat
    while nom_candidat not in self.candidate_data:
        print("Désolé, le candidat que vous avez choisi n'est pas enregistré.")
        nom_candidat = input("Entrez un autre nom de candidat correct: ---> ")

    self.candidate_data[nom_candidat]['Voix'] += 1
    print("Votre vote a été enregistré avec succès!")

    if 'second_round' in self.candidate_data[nom_candidat] and self.candidate_data[nom_candidat]['second_round']:
        # Si le candidat est déjà sélectionné pour le deuxième tour, ne pas le réinsérer
        pass
    else:
        # Marquer les deux candidats les mieux classés pour le deuxième tour
       _candidates = sorted(self.candidate_data.items(), key=lambda x: x[1]['Voix'], reverse=True)[:2]
        for candidate, data_elected in self.candidate_data.items():
            if (candidate, data_elected) in top_candidates:
                data_elected['second_round'] = True

    self.voter_data[age] = {
        'Lib_com': Lib_com,
        'nom_candidat': nom_candidat
    }

Avec cette modification, lorsque les électeurs votent, les deux candidats les mieux classés seront automatiquement marqués comme participants au deuxième tour.

Quant à la prédiction du vainqueur parmi les deux candidats au deuxième tour, votre modèle d'apprentissage semi-supervisé nécessiterait des données supplémentaires et des algorithmes spécifiques pour prédire avec précision le vainqueur. Ces algorithmes pourraient inclure des méthodes d'apprentissage semi-supervisé telles que l'apprentissage par renforcement, la co-formation, ou des modèles de mélange gaussien semi-supervisés, selon la quantité de données labellisées disponibles.

Si vous avez des données labellisées pour une partie des électeurs au deuxième tour, vous pourriez entraîner un modèle sur ces données et utiliser diverses techniques d'apprentissage semi-supervisé pour étendre le modèle à des données non labellisées.

L'apprentissage semi-supervisé nécessite une manipulation minutieuse des données et des choix d'algorithmes appropriés pour obtenir des prédictions précises en utilisant à la fois des données labellisées et non labellisées.

En utilisant algorithme du K-Means qu'est-ce que ça peut donner comme prédiction du vainqueur ?

L'algorithme K-Means est un algorithme de clustering non supervisé souvent utilisé pour regrouper des données en fonction de leurs similarités. Cependant, il est important de noter que le K-Means est un algorithme non supervisé et n'est donc pas directement adapté à la prédiction du vainqueur dans un contexte de vote politique.

Néanmoins, il est possible'utiliser l'algorithme K-Means dans un cadre semi-supervisé pour tenter de prédire le vainqueur parmi les candidats au deuxième tour. Voici comment cela pourrait être abordé :

Utilisation des données disponibles : Vous pouvez utiliser les données des électeurs qui ont voté au deuxième tour, en les utilisant comme données d'entrée pour l'algorithme K-Means. Cela pourrait inclure des caractéristiques telles que l'âge, la localisation géographique et éventuellement les préférences politiques déclarées.
Entraînement du modèle : En utilisant les données disponibles des électeurs qui ont voté au deuxième tour, vous pouvez entraîner un modèle K-Means semi-supervisé pour regrouper les électeurs en fonction de leurs similitudes.
Analyse des clusters : Une fois que le modèle K-Means a regroupé les électeurs en clusters, vous pourriez examiner le cluster auquel chaque candidat appartient le plus pour obtenir une indication de leur popularité dans différents groupes d'électeurs.

Il est important de noter que l'efficacité de cette approche dépend grandement de la qualité et de la quantité des données disponibles, ainsi que de la représentativité des caractéristiques utilisées pour former les clusters.

Il convient également de noter que ce scénario suppose que les électeurs au deuxième tour seront regroupés de manière significative autour des préférences politiques, ce qui peut ne pas être toujours le cas. Il est également important de considérer d'autres variables pertinentes telles que les campagnes politiques, les événements actuels, etc., qui pourraient influencer le résultat du vote.

Ainsi, bien que l'algorithme K-Means puisse être utilisé dans un cadre semi-supervisé pour fournir des indications sur les préférences des électeurs, il est crucial de l'appliquer avec prudence et de considérer d'autres approaches en fonction des données et du contexte spécifique de votre prédiction électorale.