'fixe'

.dockerignore

@@ -1,2 +1,2 @@
 **/__pycache__
-**/venv
+**/venv

app.py

@@ -1,32 +1,24 @@
-#load package
-from fastapi import FastAPI,HTTPException,status,UploadFile,File
+from fastapi import FastAPI, HTTPException, status, UploadFile, File, Query
+import os
 from pydantic import BaseModel
 import uvicorn
 import logging
 import torch
-from transformers import T5Tokenizer, T5ForConditionalGeneration,AutoModelForCausalLM,AutoTokenizer
+import ollama
 import os
 import numpy as np
-from openai import OpenAI
-import ollama
+from fastapi.responses import Response
+import requests
+from fastapi.middleware.cors import CORSMiddleware
+import pandas as pd 
+import io 
+#load package
+
+
+
 
-# Configurer les répertoires de cache
 os.environ['TRANSFORMERS_CACHE'] = '/app/.cache'
 os.environ['HF_HOME'] = '/app/.cache'
-# Charger le modèle et le tokenizer
-# model_name = "models/models--t5-base/snapshots/a9723ea7f1b39c1eae772870f3b547bf6ef7e6c1"
-# tokenizer = T5Tokenizer.from_pretrained(model_name)
-# model = T5ForConditionalGeneration.from_pretrained(model_name)
-# model = AutoModelForCausalLM.from_pretrained("THUDM/longwriter-glm4-9b", trust_remote_code=True)
-# tokenizer = AutoTokenizer.from_pretrained("THUDM/longwriter-glm4-9b", trust_remote_code=True)
-
-# Configuration du client OpenAI avec l'API NVIDIA
-client = OpenAI(
-    base_url="https://integrate.api.nvidia.com/v1",
-    api_key="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"
-)
- 
-#Additional information
  
 Informations = """ 
 -text : Texte à resumé 
@@ -37,37 +29,112 @@ output:
 
 app =FastAPI(
     title='Text Summary',
-    description =Informations
+    description ='Informations'
 )  
  
 #class to define the input text 
 logging.basicConfig(level=logging.INFO)
 logger =logging.getLogger(__name__)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-
+DEFAULT_PROMPT1 = "Faites en sorte que le résumé soit riche en informations, tout en restant concis. Assurez-vous de capter les préoccupations du Client et la manière dont elles ont été traitées à travers le processus.tout doit être en français "
 default_prompt = """Bonjour,
-en tant qu’expert dans la gestion et le traitement de plaintes réseaux chez un opérateur de télécommunications, fais moi un descriptif clair de la situation concernant la plainte dont les informations sont fournies plus bas dans ce message. Ecris la situation en 4 ou 5 phrases claires et concises, fais comme si tu parlais à un humain et rajoutes les informations relatives au Client pour une meilleure connaissance de ce dernier ainsi que des éléments de dates/délais pour être précis sur le traitement de la plainte. N’hésites pas à innover sur le ton à utiliser car n’oublies pas que tu dois faire comme si tu parlais à un humain. Ce ton peut être adapté et ne pas toujours être le même en fonction des cas.
-Pour m’éviter de lire tout le détail de la plainte (voir le texte partagé plus bas), essayes de trouver toutes les informations utiles permettant de mieux appréhender la situation, par exemple : si les coordonnées GPS (Lat, Lon) sont disponibles essayes de m'indiquer le lieu où est survenue la plainte même de manière approximative. Essayes également de glaner sur internet toutes les informations pouvant aider à mieux comprendre et traiter la plainte (cela peut inclure des informations des réseaux sociaux, des concurrents, etc.) tout en priorisant dans l’analyse les informations fournies dans le texte plus bas; informations qui ont été renseignées par les experts internes chez l’opérateur de télécommunications en question et qui sont structurées en plusieurs sections :
+en tant qu'expert dans la gestion et le traitement de plaintes réseaux chez un opérateur de télécommunications, fais moi un descriptif clair de la situation concernant la plainte dont les informations sont fournies plus bas dans ce message. Ecris la situation en 4 ou 5 phrases claires et concises, fais comme si tu parlais à un humain et rajoutes les informations relatives au Client pour une meilleure connaissance de ce dernier ainsi que des éléments de dates/délais pour être précis sur le traitement de la plainte. N'hésites pas à innover sur le ton à utiliser car n'oublies pas que tu dois faire comme si tu parlais à un humain. Ce ton peut être adapté et ne pas toujours être le même en fonction des cas.
+Pour m'éviter de lire tout le détail de la plainte (voir le texte partagé plus bas), essayes de trouver toutes les informations utiles permettant de mieux appréhender la situation, par exemple : si les coordonnées GPS (Lat, Lon) sont disponibles essayes de m'indiquer le lieu où est survenue la plainte même de manière approximative. Essayes également de glaner sur internet toutes les informations pouvant aider à mieux comprendre et traiter la plainte (cela peut inclure des informations des réseaux sociaux, des concurrents, etc.) tout en priorisant dans l'analyse les informations fournies dans le texte plus bas; informations qui ont été renseignées par les experts internes chez l'opérateur de télécommunications en question et qui sont structurées en plusieurs sections :
 a) Un titre de la plainte
-b) Une section avec les Détails de la Plainte contenant l’objet, le numéro client, l’expéditeur, la date de création, les coordonnées géographiques (lat, lon)
-c) Une section avec les états d’avancement incluant les échanges (sous format chat) entre les différents acteurs impliqués dans le traitement de la plainte
+b) Une section avec les Détails de la Plainte contenant l'objet, le numéro client, l'expéditeur, la date de création, les coordonnées géographiques (lat, lon)
+c) Une section avec les états d'avancement incluant les échanges (sous format chat) entre les différents acteurs impliqués dans le traitement de la plainte
 d) Une section contenant les éléments relatifs à la qualification de la plainte (type de plainte, origine, domaine, sous-domaine, etc…)
 e) Une section avec les fichiers joints à la plainte et autres pièces jointes pour mieux comprendre et trouver une solution à cette plainte en vue de satisfaire le Client
  
-Dans la situation que tu vas me donner (en quelques 4 ou 5 phrases comme si tu t’adresses à un humain), assures toi que les points cruciaux (voire rédhibitoires) ci-dessous sont bien présents :
+Dans la situation que tu vas me donner (en quelques 4 ou 5 phrases comme si tu t'adresses à un humain), assures toi que les points cruciaux (voire rédhibitoires) ci-dessous sont bien présents :
 1) Ecris la situation en 4 ou 5 phrases claires et concises, fais comme si tu parlais à un humain
 2) Rajoutes les informations relatives au Client pour être précis sur la connaissance de ce dernier.
 3) Rajoutes des éléments de dates (remontée, transfert, prise en charge, résolution, clôture, etc…) ainsi que les délais (par exemple de réponse des différents acteurs ou experts de la chaine de traitement) pour mieux apprécier l'efficacité du traitement de la plainte.
-4) Rajoutes à la fin une recommandation importante afin d'éviter le mécontentement du Client par exemple pour éviter qu’une Plainte ne soit clôturée sans solution pour le Client notamment et à titre illustratif seulement dans certains cas pour un Client qui a payé pour un service et ne l'a pas obtenu, On ne peut décemment pas clôturer sa plainte sans solution en lui disant d’être plus vigilant, il faut recommander à l’équipe en charge de la plainte de le rembourser ou de trouver un moyen de donner au Client le service pour lequel il a payé (à défaut de le rembourser).
-5) N’hésites pas à innover sur le ton à utiliser car n’oublies pas que tu dois faire comme si tu parlais à un humain. Ce ton peut être adapté et ne pas toujours être le même en fonction des cas.
+4) Rajoutes à la fin une recommandation importante afin d'éviter le mécontentement du Client par exemple pour éviter qu'une Plainte ne soit clôturée sans solution pour le Client notamment et à titre illustratif seulement dans certains cas pour un Client qui a payé pour un service et ne l'a pas obtenu, On ne peut décemment pas clôturer sa plainte sans solution en lui disant d'être plus vigilant, il faut recommander à l'équipe en charge de la plainte de le rembourser ou de trouver un moyen de donner au Client le service pour lequel il a payé (à défaut de le rembourser).
+5) N'hésites pas à innover sur le ton à utiliser car n'oublies pas que tu dois faire comme si tu parlais à un humain. Ce ton peut être adapté et ne pas toujours être le même en fonction des cas.
 """
 instructions_par_defaut = (
-        "Vous êtes un expert en service client. Résumez la plainte suivante en extrayant les informations clés : "
-        "1. Objet de la plainte. "
-        "2. Détails incluant le numéro client, le problème et les dates importantes. "
-        "3. Actions prises et suivis incluant les dates et les personnes impliquées. "
-        "4. Toute action supplémentaire ou recommandation nécessaire."
-    )
+    "Fais moi un résumé détaillé de ce plainte : "
+    "1. Objet de la plainte. "
+    "2. Détails incluant le numéro client, le problème et les dates importantes. "
+    "3. Actions prises et suivis incluant les dates et les personnes impliquées. "
+    "4. Toute action supplémentaire ou recommandation nécessaire."
+)
+prompt_week = "Tu es un assistant IA chargé d'analyser qualitativement les plaintes clients. Je te fournis un ensemble de plaintes contenant la date de création, l'objet de la plainte, le statut, et le domaine. Je souhaite que tu réalises une analyse qualitative en listant le nombre de plaintes par statut et en identifiant les plaintes les plus fréquentes de cette semaine, tout en fournissant des recommandations. Commence par indiquer la période, par exemple : 'La semaine du [date de début] au [date de fin]'.Ne te presente pas juste donne l'analyse"
+
+prompt_month = """
+Fais moi une analyse qualitative en prenant en compte le nombre de plainte par status.
+Les données fournies incluent des plaintes clients avec des informations sur le statut, le domaine,la date de creation  et des détails descriptifs. Ton objectif est de fournir une analyse détaillée prenant en compte :**Résumé général du mois :**
+
+- Période :donne le mois et l'annee en se basant sur la 
+**Répartition des plaintes par domaine :**
+- Domaine donne le nom du domaine :
+  - Total des plaintes : [Nombre total de plaintes]
+  - Statuts des plaintes :
+    - En cours : [Nombre]
+    - Transférées : [Nombre]
+    - Fermées : [Nombre]
+    - Non pris en charge : [Nombre]
+    - Autres statuts : [Nombre]
+**Problèmes récurrents observés ce mois-ci :**
+- Listez 1 à 2 problèmes les plus fréquents. Soyez précis et évitez les généralisations.
+**Actions entreprises :**
+- Listez les actions entreprises. Incluez le temps moyen de traitement des plaintes par statut durant ce mois et les intervenants les plus fréquents dans la résolution des plaintes.
+**Recommandations pour améliorer la gestion des plaintes :**
+1. Faites des recommandations claires et concrètes.
+En résumé, voici les principales tendances et recommandations pour améliorer la gestion des plaintes et résoudre les problèmes identifiés ce mois-ci.
+
+        """
+DEFAULT_P = """
+Fais moi une analyse qualitative en prenant en compte le nombre de plainte par status.
+Les données fournies incluent des plaintes clients avec des informations sur le statut, le domaine,la date de creation  et des détails descriptifs. Ton objectif est de fournir une analyse détaillée prenant en compte :
+0. la periode de la plainte en se basant sur la date de creation
+1. La répartition des plaintes par statut ('FERME', 'TRANSFERE', 'EN COURS', 'NON PREVU', 'TRAITE',
+       'EN ATTENTE', 'NON PRIS EN CHARGE') dans le domaine pour la semaine spécifiée seulement des statut qui apparait dans la plainte.
+2. Le temps moyen de traitement des plaintes par statut durant cette semaine.
+3. Les intervenants les plus fréquents dans la résolution des plaintes pour cette semaine.
+4. Les actions concrètes menées pour résoudre les plaintes cette semaine.
+5. Les problèmes récurrents observés dans les plaintes cette semaine (réception, facturation, réseau, etc.).
+6. Des recommandations pour améliorer la gestion des plaintes et résoudre les problèmes identifiés pour cette semaine.
+Voici un exemple d'information :
+- Domaine : "Domaine général prend seulement le domaine qui apparait" (par ex. 'FIXE', 'OM', 'MOBILE', 'DATA_MOBILE', 'TVO', 'SVA', 'SMS',
+       'FLYBOX', 'ROAMING', 'LS', 'INTERNATIONAL', 'COMMUTATION',
+       'SERVEUR', 'OUTIL', 'BACKBONE_TRANS', 'IP', nan, 'Max-it',
+       'ANALYSE SITE SUITE BAISSE CA', '5G_FLYBOX', 'BACKBONE_ID',
+       'MULTIMEDIA', '5G_MOBILE', 'VOIX_MOBILE', 'USSD', 'IP_ADSL').
+- Statut : 'FERME(2)', 'TRANSFERE(1)', 'EN COURS(3)', 'NON PREVU(1)', 'TRAITE(é)',
+       'EN ATTENTE(2)', 'NON PRIS EN CHARGE(4)'
+- Détails de la plainte : erreurs, problème de service, etc.
+- Intervenants : équipes techniques, support client, etc.
+- Temps de traitement moyen par statut (uniquement pour la semaine en question).
+
+"""
+prompt_all ="""
+**Analyse des plaintes**
+Fournissez une analyse qualitative détaillée des plaintes selon les critères suivants :
+-* Répartition des plaintes par domaine (MOBILE, FIXE, DATA_MOBILE, OM)
+-* Répartition des plaintes par statut (FERME, TRANSFERE, EN COURS, NON PRIS EN CHARGE)\n
+-* Analyse des plaintes par domaine : problèmes rencontrés, région/cité mentionnée
+-* Tendances importantes dans les plaintes (augmentation/diminution du nombre de plaintes)
+-* Recommandations pour résoudre les problèmes signalés
+-* Analyse des progrès : plaintes résolues, statistiques sur l'évolution du traitement des plaintes
+-**Objectifs**\n\nEn fournissant cette analyse, je souhaite :
+    1.* Comprendre la répartition des plaintes par domaine et statut
+    2.* Identifier les tendances importantes dans les plaintes et proposer des recommandations pour y remédier
+    3.* Analyser les progrès faits dans le traitement des plaintes et identifier les domaines où il est possible de faire des améliorations
+"""
+prompt_month2 = """Tu es un assistant IA  chargé d'analyser qualitativement les plaintes clients. 
+Je te fournis un ensemble de plaintes contenant la date de création, l'objet de la plainte, le statut, et le domaine. 
+Je souhaite que tu réalises une analyse qualitative en français en listant le nombre de plaintes par statut et 
+ identifiant les plaintes les plus fréquentes de ce mois, tout en fournissant des recommandations pertinentes. 
+ Commence par indiquer la période.Ne te presente pas juste donne l'analyse"""
 class TextSummary(BaseModel): 
     prompt:str 
     
@@ -78,38 +145,200 @@ async def home():
 # Modèle pour la requête
 class RequestModel(BaseModel):
     text: str
-
 @app.post("/generate/")
 async def generate_text(request: RequestModel):
-    # Créer la requête pour l'API NVIDIA
-    # completion = client.chat.completions.create(
-    #     model="meta/llama-3.1-8b-instruct", 
-    #     messages=[{"role": "user", "content": default_prompt + request.text}],
-    #     temperature=0.2,
-    #     top_p=0.7,
-    #     max_tokens=1024,
-    #     stream=True
-    # )
-    response = ollama.chat(
-        model="llama3",
-        messages=[
-            {
-                "role": "user",
-                "content": default_prompt + request.text,
-            },
-        ],
-    )
-    # Générer le texte en temps réel
+    # Assurer la configuration pour une utilisation optimale de la mémoire
+    try:
+        # Combinaison du prompt par défaut et du texte de l'utilisateur
+        full_prompt = default_prompt + request.text
+        text1 = request.text
+        # Utilisation de l'API Ollama
+        res = requests.post('http://127.0.0.1:11434/api/generate', json={
+            "prompt": full_prompt,
+            "stream": False,
+            "model": "llama3.2"
+        })
+        
+        # Vérification de la réponse
+        if res.status_code != 200:
+            print("response",res)
+            raise HTTPException(status_code=res.status_code, detail="Erreur de l'API Ollama")
+        # Extraction du texte généré
+        generated_text = res.json().get('response', '')
+
+        # Traitement du texte pour supprimer les phrases génériques
+        intro_phrases = [
+            "Voici un résumé de la plainte en 5 phrases :",
+            "Résumé :",
+            "Voici ce qui s'est passé :",
+            "Cette plainte a été déposée par"
+        ]
+        
+        for phrase in intro_phrases:
+            if generated_text.startswith(phrase):
+                generated_text = generated_text[len(phrase):].strip()
+                break
+
+        return {"summary_text_2": generated_text}
+
+    except requests.RequestException as e:
+        raise HTTPException(status_code=500, detail=f"Erreur de requête : {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur inattendue : {str(e)}")
+@app.post("/analyse/")
+async def generate_text(
+    period: str = Query(..., description="Choisissez entre 'semaine' ou 'mois'"),
+    file: UploadFile = File(...)):
     
-    generated_text = response["message"]["content"]
-    # for chunk in completion:
-    #     if chunk.choices[0].delta.content is not None:
-    #         generated_text += chunk.choices[0].delta.content
+    # Check file size 
+    contents = await file.read()
+    file_size = len(contents)
+    
+    if file_size > 5_000_000:  # 5MB limit
+        return {"error": "File size exceeds the 5MB limit. The file will be sampled."}
+
+    # Read the uploaded CSV file
+    try:
+        df = pd.read_csv(io.StringIO(contents.decode('utf-8')))
+        # logging.info(f"DataFrame content: {df}")
+
+    except Exception as e:
+        return {"error": f"Error reading CSV file: {str(e)}"}
+
+    # Sample the data if it's too large
+    if len(df) > 1000:  # Adjust this number based on your needs
+        df = df.sample(n=100, random_state=42)
+
+    # Convert the DataFrame to a string
+    try:
+        text_to_generate = df.to_string(index=False)
+        # logging.info(f"Generated text: {text_to_generate}")
+    except Exception as e:
+        return {"error": f"Error converting DataFrame to string: {str(e)}"}
+
+    # Ensure the generated text is within size limits
+    if len(text_to_generate.encode('utf-8')) > 5_000_000:
+        return {"error": "Generated text exceeds size limit even after sampling. Please reduce the data further."}
+
+    # Define the appropriate prompt based on the period (week or month)
+    prompt = ""
+    if period == "semaine":
+        prompt = prompt_week
+    elif period == "mois":
+        prompt = prompt_month2
+    else:
+        return {"error": "Invalid period. Choose either 'semaine' or 'mois'."}
+
+    # Create the request for the Ollama API
+    try:
+        res = requests.post('http://127.0.0.1:11434/api/generate', json={
+            "prompt": prompt + text_to_generate,
+            "stream": False,
+            "model": "llama3"
+        })
+        
+        if res.status_code == 200:
+            generated_text = res.json().get('response', '')
+        else:
+            return {"error": f"Error in Ollama API request: Status code {res.status_code}"}
+    except Exception as e:
+        return {"error": f"Error generating text: {str(e)}"}
+
+    return {"summary_text_2": generated_text}
+@app.post("/analyse_globale/")
+async def generate_global_analysis(file: UploadFile = File(...)):
+    # Lire le fichier téléchargé
+    contents = await file.read()
+
+    # Vérification de la taille du fichier
+    file_size = len(contents)
+    if file_size > 5_000_000:  # Limite de 5 Mo
+        return {"error": "La taille du fichier dépasse la limite de 5 Mo. Le fichier sera échantillonné."}
+
+    # Lire le fichier CSV téléchargé
+    try:
+        df = pd.read_csv(io.StringIO(contents.decode('utf-8')))
+    except Exception as e:
+        return {"error": f"Erreur lors de la lecture du fichier CSV : {str(e)}"}
+
+    # Échantillonner les données si elles sont trop grandes
+    if len(df) > 1000:  # Ajustez ce nombre selon vos besoins
+        df = df.sample(n=500, random_state=42)
+    # Convertir le DataFrame en chaîne de caractères
+    try:
+        text_to_generate = df.to_string(index=False)
+    except Exception as e:
+        return {"error": f"Erreur lors de la conversion du DataFrame en chaîne : {str(e)}"}
+
+    # S'assurer que le texte généré est dans les limites de taille
+    if len(text_to_generate.encode('utf-8')) > 5_000_000:
+        return {"error": "Le texte généré dépasse la limite de taille même après échantillonnage. Veuillez réduire davantage les données."}
+    
+    # Groupement des données par domaine
+    domain_analyses = ""
+    for domain, group in df.groupby('DOMAINE'):
+        domain_summary = group.groupby('STATUT').size().to_dict()
+        domain_analysis = f"""
+        - Domaine "{domain}" :
+          - Total des plaintes : {len(group)}
+          - Répartition par statut :
+            - En cours : {domain_summary.get('EN COURS', 0)}
+            - Transférées : {domain_summary.get('TRANSFERE', 0)}
+            - Fermées : {domain_summary.get('FERME', 0)}
+            - Non pris en charge : {domain_summary.get('NON PRIS EN CHARGE', 0)}
+            - Autres statuts : {sum(v for k, v in domain_summary.items() if k not in ['EN COURS', 'TRANSFERE', 'FERME', 'NON PRIS EN CHARGE'])}
+        """
+        domain_analyses += domain_analysis
+        # logging.info(f"domaine text: {domain_analyses}")
+    # Définir le prompt de l'analyse globale
+    # Prompt amélioré pour l'analyse globale
+    total_plaintes = len(df)
+    prompt_global1=f"""Tu es un assistant IA  chargé d'analyser qualitativement les plaintes clients. 
+Je te fournis un ensemble de plaintes contenant la date de création, l'objet de la plainte, le statut, et le domaine et ces information {domain_analyses} . 
+Je souhaite que tu réalises une analyse qualitative en français en listant le nombre de plaintes par statut et 
+ identifiant les plaintes les plus fréquentes de ce mois, tout en fournissant des recommandations pertinentes. 
+ Commence par indiquer la période.Ne donne pas ton avis soit clair et conscis et s'il te plait Ne te presente pas juste donne l'analyse"""
+    prompt_global = f"""
+    Fais moi une analyse qualitative détaillée des plaintes selon ces critères :
+    Je te fournis un tableau détaillant les plaintes classées par domaine et par statut. Voici les informations :
+    Afficher ces informations d'abord:
+    - Nombre totale plaintes{domain_analyses}
+
+    - Nombre total de plaintes : {total_plaintes}
+
+    
+    1. Résume les problèmes les plus fréquents par domaine en fonction des différents statuts (EN COURS, TRANSFERE, FERME, etc.).
+    2. Pour chaque domaine, identifie les tendances importantes, telles que les augmentations ou diminutions du nombre de plaintes selon les statuts.
+    3. Propose des recommandations spécifiques pour chaque domaine où le nombre de plaintes 'EN COURS' ou 'TRANSFERE' est élevé.
+    4. Analyse les progrès dans les domaines où un nombre significatif de plaintes a été 'FERME' récemment.
+    5. Fournis une analyse des plaintes par statut pour chaque domaine, en mettant en évidence les problèmes les plus critiques et les domaines qui nécessitent une attention particulière.
+    6. Propose des suggestions concrètes pour améliorer le traitement des plaintes, réduire les délais de résolution, et améliorer la satisfaction des clients.
+
+    Merci de fournir une analyse professionnelle, concise et axée sur les données.
+    """
+
+
+
+    # Création de la requête pour l'API Ollama
+    try:
+        res = requests.post('http://127.0.0.1:11434/api/generate', json={
+            "prompt": prompt_global1 + text_to_generate,
+            "stream": False,
+            "model": "llama3"
+        })
+        
+        if res.status_code == 200:
+            generated_text = res.json().get('response', '')
+        else:
+            return {"error": f"Erreur dans la requête API Ollama : Code de statut {res.status_code}"}
+    except Exception as e:
+        return {"error": f"Erreur lors de la génération du texte : {str(e)}"}
+
+    # Retour du texte généré
+    return {"global_analysis_text": generated_text}
 
-    return {"generated_text": generated_text}
 if __name__ == "__main__":
-    uvicorn.run("app:app",reload=True) 
+    uvicorn.run("app:app",host="0.0.0.0", port=8000,reload=True) 
 
 
 
- 

app1.py

@@ -1,86 +1,89 @@
-#load package
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-import torch
-from transformers import (
-    AutoModelForCausalLM,
-    AutoTokenizer
-)
-from typing import List, Tuple
-from threading import Thread
-import os
-from pydantic import BaseModel
-import logging
 import uvicorn
+import logging
+import os
+from fastapi.middleware.cors import CORSMiddleware
+from transformers import AutoTokenizer, AutoModelForCausalLM
 
-
-# Configurer les répertoires de cache
+# Configurer les répertoires de cache pour Transformers
 os.environ['TRANSFORMERS_CACHE'] = '/app/.cache'
 os.environ['HF_HOME'] = '/app/.cache'
-# Charger le modèle et le tokenizer
-model = AutoModelForCausalLM.from_pretrained("THUDM/longwriter-glm4-9b", trust_remote_code=True, device_map='auto')
-tokenizer = AutoTokenizer.from_pretrained("THUDM/longwriter-glm4-9b", trust_remote_code=True)
 
- 
-#Additional information
- 
+# Informations générales pour l'API
 Informations = """ 
--text : Texte à resumé 
+-text : Texte à resumer
 
 output:
 - Text summary : texte resumé
 """
 
-app =FastAPI(
+app = FastAPI(
     title='Text Summary',
-    description =Informations
-)  
-default_prompt = """Bonjour,
+    description=Informations
+)
+
+# Configurer les logs
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-En tant qu’expert en gestion des plaintes réseaux, rédige un descriptif clair de la plainte ci-dessous. Résume la situation en 4 ou 5 phrases concises, en mettant l'accent sur :
-1. **Informations Client** : Indique des détails pertinents sur le client.
-2. **Dates et Délais** : Mentionne les dates clés et les délais (prise en charge, résolution, etc.).
-3. **Contexte et Détails** : Inclut les éléments essentiels de la plainte (titre, détails, états d’avancement, qualification, fichiers joints).
+# Ajouter le middleware CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-Ajoute une recommandation importante pour éviter le mécontentement du client, par exemple, en cas de service non fourni malgré le paiement. Adapte le ton pour qu'il soit humain et engageant.
+# Prompt par défaut
+DEFAULT_PROMPT = "Fais nous un résumé descriptif en français de la plainte suivante en 4 phrases concises, en vous concentrant sur les faits principaux et en évitant toute introduction générique. Nettoie également le texte si nécessaire : "
 
-Merci !
+# Modèle de la requête
+class RequestModel(BaseModel):
+    text: str
 
-"""
-#class to define the input text 
-logging.basicConfig(level=logging.INFO)
-logger =logging.getLogger(__name__)
-# Définir le modèle de requête
-class PredictionRequest(BaseModel):
-    text: str = None  # Texte personnalisé ajouté par l'utilisateur
-    # max_length: int = 2000  # Limite la longueur maximale du texte généré
-
-@app.post("/predict/")
-async def predict(request: PredictionRequest):
-    # Construire le prompt final
-    if request.text:
-        prompt = default_prompt + "\n\n" + request.text
-    else:
-        prompt = default_prompt
-
-    # Tokenize l'entrée et créez un attention mask
-    inputs = tokenizer(prompt, return_tensors="pt", padding=True, truncation=True)
-    input_ids = inputs.input_ids.to(model.device)
-    attention_mask = inputs.attention_mask.to(model.device)
-
-    # Générez le texte en passant l'attention mask
-    outputs = model.generate(
-        input_ids,
-        attention_mask=attention_mask,
-        max_length=3000,
-        do_sample=True
-    )
-    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    
-    return {"generated_text": generated_text}
+# Charger le modèle et le tokenizer
+model_name = "models/models--meta-llama--Meta-Llama-3.1-8B-Instruct/snapshots/5206a32e0bd3067aef1ce90f5528ade7d866253f"
+tokenizer = AutoTokenizer.from_pretrained(model_name,token="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")
+model = AutoModelForCausalLM.from_pretrained(model_name,token="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")
 
-if __name__ == "__main__":
-    uvicorn.run("app:app",reload=True) 
+@app.get("/")
+async def home():
+    return 'STN BIG DATA'
+
+@app.post("/generate/")
+async def generate_text(request: RequestModel):
+    try:
+        # Combiner le prompt par défaut et le texte de l'utilisateur
+        full_prompt = DEFAULT_PROMPT + request.text
 
+        # Tokeniser l'entrée
+        input_ids = tokenizer.encode(full_prompt, return_tensors="pt")
 
- 
+        # Générer du texte avec le modèle
+        output = model.generate(input_ids, max_length=150, num_return_sequences=1)
+
+        # Décoder la sortie pour obtenir le texte généré
+        generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
+
+        # Optionnel : nettoyage du texte généré pour enlever les phrases génériques
+        intro_phrases = [
+            "Voici un résumé de la plainte en 5 phrases :",
+            "Résumé :",
+            "Voici ce qui s'est passé :",
+            "Cette plainte a été déposée par"
+        ]
+        
+        for phrase in intro_phrases:
+            if generated_text.startswith(phrase):
+                generated_text = generated_text[len(phrase):].strip()
+                break
+        
+        return {"summary_text": generated_text}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur inattendue : {str(e)}")
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=8080, reload=True)

app3.py

@@ -1,86 +0,0 @@
-#load package
-from fastapi import FastAPI
-from pydantic import BaseModel
-import torch
-from transformers import (
-    AutoModelForCausalLM,
-    AutoTokenizer
-)
-from typing import List, Tuple
-from threading import Thread
-import os
-from pydantic import BaseModel
-import logging
-import uvicorn
-
-
-# Configurer les répertoires de cache
-os.environ['TRANSFORMERS_CACHE'] = '/app/.cache'
-os.environ['HF_HOME'] = '/app/.cache'
-# Charger le modèle et le tokenizer
-model = AutoModelForCausalLM.from_pretrained("THUDM/longwriter-glm4-9b", trust_remote_code=True, device_map='auto')
-tokenizer = AutoTokenizer.from_pretrained("THUDM/longwriter-glm4-9b", trust_remote_code=True)
-
- 
-#Additional information
- 
-Informations = """ 
--text : Texte à resumé 
-
-output:
-- Text summary : texte resumé
-"""
-
-app =FastAPI(
-    title='Text Summary',
-    description =Informations
-)  
-default_prompt = """Bonjour,
-
-En tant qu’expert en gestion des plaintes réseaux, rédige un descriptif clair de la plainte ci-dessous. Résume la situation en 4 ou 5 phrases concises, en mettant l'accent sur :
-1. **Informations Client** : Indique des détails pertinents sur le client.
-2. **Dates et Délais** : Mentionne les dates clés et les délais (prise en charge, résolution, etc.).
-3. **Contexte et Détails** : Inclut les éléments essentiels de la plainte (titre, détails, états d’avancement, qualification, fichiers joints).
-
-Ajoute une recommandation importante pour éviter le mécontentement du client, par exemple, en cas de service non fourni malgré le paiement. Adapte le ton pour qu'il soit humain et engageant.
-
-Merci !
-
-"""
-#class to define the input text 
-logging.basicConfig(level=logging.INFO)
-logger =logging.getLogger(__name__)
-# Définir le modèle de requête
-class PredictionRequest(BaseModel):
-    text: str = None  # Texte personnalisé ajouté par l'utilisateur
-    # max_length: int = 2000  # Limite la longueur maximale du texte généré
-
-@app.post("/predict/")
-async def predict(request: PredictionRequest):
-    # Construire le prompt final
-    if request.text:
-        prompt = default_prompt + "\n\n" + request.text
-    else:
-        prompt = default_prompt
-
-    # Tokenize l'entrée et créez un attention mask
-    inputs = tokenizer(prompt, return_tensors="pt", padding=True, truncation=True)
-    input_ids = inputs.input_ids.to(model.device)
-    attention_mask = inputs.attention_mask.to(model.device)
-
-    # Générez le texte en passant l'attention mask
-    outputs = model.generate(
-        input_ids,
-        attention_mask=attention_mask,
-        max_length=3000,
-        do_sample=True
-    )
-    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    
-    return {"generated_text": generated_text}
-
-if __name__ == "__main__":
-    uvicorn.run("app:app",reload=True) 
-
-
- 

app4.py

@@ -1,12 +0,0 @@
-import ollama
-
-response = ollama.chat(
-    model="llama3",
-    messages=[
-        {
-            "role": "user",
-            "content": "Tell me an interesting fact about elephants",
-        },
-    ],
-)
-print(response["message"]["content"])

requirements.txt

@@ -1,15 +1,24 @@
 fastapi==0.111.0
 torch==2.3.1
-transformers==4.44.1
 uvicorn==0.30.1
 pydantic==2.7.4
-pillow==10.3.0
 numpy
 scipy==1.11.3
-sentencepiece==0.2.0
-pytesseract==0.3.10
 Pillow==10.3.0
 BeautifulSoup4==4.12.3
 protobuf
+ollama
+requests
+transformers==4.44.0
+pytesseract==0.3.10
+spaces==0.29.2
+accelerate==0.33.0
+sentencepiece==0.2.0
+huggingface-hub==0.24.5
+jinja2==3.1.4
+sentence_transformers==3.0.1
+tiktoken==0.7.0
+einops==0.8.0
+ollama
 openai==1.42.0
-ollama
+pandas