RacoGPT skeleton app

app.py

@@ -0,0 +1,98 @@
+import streamlit as st
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+from streamlit import session_state as ss
+import os
+import login  # Importa il file login.py che hai creato
+
+# Inizializza lo stato di login se non esiste
+if "is_logged_in" not in st.session_state:
+    st.session_state["is_logged_in"] = False
+
+# Mostra la pagina di login solo se l'utente non è loggato
+if not st.session_state["is_logged_in"]:
+    login.login_page()  # Mostra la pagina di login e blocca il caricamento della chat
+    st.stop()
+
+# Recupera le secrets da Hugging Face
+model_repo = os.getenv("MODEL_REPO")  # Repository del modello di base
+hf_token = os.getenv("HF_TOKEN")  # Token Hugging Face
+
+# Carica il modello di base con caching
+@st.cache_resource
+def load_model():
+    tokenizer = AutoTokenizer.from_pretrained(model_repo, use_auth_token=hf_token)
+    model = AutoModelForCausalLM.from_pretrained(model_repo, use_auth_token=hf_token)
+    model.config.use_cache = True
+    return tokenizer, model
+
+# Funzione per generare una risposta in tempo reale
+def generate_llama_response_stream(user_input, tokenizer, model, max_length=512):
+    eos_token = tokenizer.eos_token if tokenizer.eos_token else ""
+    input_ids = tokenizer.encode(user_input + eos_token, return_tensors="pt")
+    response_text = ""
+
+    response_placeholder = st.empty()  # Placeholder per mostrare la risposta progressiva
+
+    # Genera un token alla volta e aggiorna il placeholder
+    for i in range(max_length):
+        output = model.generate(input_ids, max_new_tokens=1, pad_token_id=tokenizer.eos_token_id, use_cache=True)
+        new_token_id = output[:, -1].item()
+        new_token = tokenizer.decode([new_token_id], skip_special_tokens=True)
+
+        response_text += new_token
+        response_placeholder.markdown(f"**RacoGPT:** {response_text}")  # Aggiorna il testo progressivo
+
+        # Aggiungi il nuovo token alla sequenza di input
+        input_ids = torch.cat([input_ids, output[:, -1:]], dim=-1)
+
+        # Interrompe se il token generato è <|endoftext|> o eos_token_id
+        if new_token_id == tokenizer.eos_token_id:
+            break
+
+    return response_text
+
+# Inizializza lo stato della sessione
+if 'is_chat_input_disabled' not in ss:
+    ss.is_chat_input_disabled = False
+
+if 'msg' not in ss:
+    ss.msg = []
+
+if 'chat_history' not in ss:
+    ss.chat_history = None
+
+# Carica il modello e tokenizer
+tokenizer, model = load_model()
+
+# Mostra la cronologia dei messaggi con le label personalizzate
+for message in ss.msg:
+    if message["role"] == "user":
+        with st.chat_message("user"):
+            st.markdown(f"**Tu:** {message['content']}")
+    elif message["role"] == "RacoGPT":
+        with st.chat_message("RacoGPT"):
+            st.markdown(f"**RacoGPT:** {message['content']}")
+
+# Gestione dell'input e disabilitazione
+if (prompt := st.chat_input("Scrivi il tuo messaggio...", disabled=ss.is_chat_input_disabled) or "").strip():
+
+    # Salva il messaggio dell'utente e disabilita l'input
+    if not ss.is_chat_input_disabled:
+        ss.msg.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            ss.is_chat_input_disabled = True
+            st.markdown(f"**Tu:** {prompt}")
+
+    # Genera la risposta del bot con digitazione in tempo reale
+    with st.spinner("RacoGPT sta generando una risposta..."):
+        response = generate_llama_response_stream(prompt, tokenizer, model)
+
+    # Mostra il messaggio finale del bot dopo che la risposta è completata
+    ss.msg.append({"role": "RacoGPT", "content": response})
+    with st.chat_message("RacoGPT"):
+        st.markdown(f"**RacoGPT:** {response}")
+    ss.is_chat_input_disabled = False
+
+    # Rerun per aggiornare l'interfaccia
+    st.rerun()

login.py

@@ -0,0 +1,44 @@
+import streamlit as st
+import psycopg2
+
+# Recupera le credenziali dal file secrets di Hugging Face Spaces
+user = st.secrets["SUPABASE_USER"]
+password = st.secrets["SUPABASE_PASSWORD"]
+host = st.secrets["SUPABASE_HOST"]
+port = st.secrets["SUPABASE_PORT"]
+dbname = st.secrets["SUPABASE_DBNAME"]
+
+# Funzione per connettersi al database
+def get_connection():
+    return psycopg2.connect(
+        user=user,
+        password=password,
+        host=host,
+        port=port,
+        dbname=dbname
+    )
+
+# Funzione per verificare l'email e la password
+def verify_user(email, password):
+    conn = get_connection()
+    cur = conn.cursor()
+    query = "SELECT * FROM users WHERE email = %s AND password = %s"
+    cur.execute(query, (email, password))
+    user = cur.fetchone()
+    cur.close()
+    conn.close()
+    return user
+
+# Funzione di login
+def login_page():
+    st.markdown("<h1 style='text-align: center;'>Accedi a RacoGPT</h1>", unsafe_allow_html=True)
+    email = st.text_input("Email", placeholder="Inserisci la tua email", key="login_email_unique")
+    password = st.text_input("Password", type="password", placeholder="Inserisci la tua password", key="login_password_unique")
+
+    if st.button("Accedi", key="login_button_unique"):
+        user = verify_user(email, password)
+        if user:
+            st.session_state["is_logged_in"] = True
+            st.rerun()  # Reindirizza alla chat
+        else:
+            st.error("Email o password non corretti.")

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+transformers
+peft
+torch
+psycopg2-binary