Upload 7 files

app.py

@@ -0,0 +1,80 @@
+from flask import Flask, render_template, request, jsonify, session
+import tensorflow as tf
+from transformers import T5Tokenizer, TFT5ForConditionalGeneration
+import joblib
+import pandas as pd
+import datetime
+
+app = Flask(__name__)
+app.secret_key = 'hassaanik'  # Necessary for session management
+
+
+# Load models and tokenizers
+counseling_greeting_model = TFT5ForConditionalGeneration.from_pretrained('./models/counseling_greeting_model/saved_model')
+counseling_greeting_tokenizer = T5Tokenizer.from_pretrained('./models/counseling_greeting_model/tokenizer')
+
+med_info_model = TFT5ForConditionalGeneration.from_pretrained('./models/medication_info_model/saved_model')
+med_info_tokenizer = T5Tokenizer.from_pretrained('./models/medication_info_model/tokenizer')
+
+knn_model = joblib.load('./models/medication_classification_model/knn_model.pkl')
+label_encoders = joblib.load('./models/medication_classification_model/label_encoders.pkl')
+age_scaler = joblib.load('./models/medication_classification_model/age_scaler.pkl')
+medication_encoder = joblib.load('./models/medication_classification_model/medication_encoder.pkl')
+
+
+# Existing model loading code...
+
+@app.route('/')
+def index():
+    session.clear()  # Clear session when accessing the homepage
+    return render_template('index.html')
+
+@app.route('/reset_chat', methods=['POST'])
+def reset_chat():
+    session.clear()
+    return jsonify({'status': 'Chat reset'})
+
+def generate_response(model, tokenizer, input_text, session_key):
+    # Prepare input for model
+    encoding = tokenizer(input_text, max_length=500, padding='max_length', truncation=True, return_tensors='tf')
+    input_ids = encoding['input_ids']
+    attention_mask = encoding['attention_mask']
+    # Generate response
+    outputs = model.generate(input_ids=input_ids, attention_mask=attention_mask, max_length=512, num_beams=5, early_stopping=True)
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    # Store in session
+    if session_key not in session:
+        session[session_key] = []
+    session[session_key].append({'user': input_text, 'bot': response})
+    return response
+
+@app.route('/counseling_greeting', methods=['POST'])
+def counseling_greeting():
+    data = request.get_json()
+    prompt = data['prompt']
+    response = generate_response(counseling_greeting_model, counseling_greeting_tokenizer, f"question: {prompt}", 'counseling_greeting')
+    return jsonify({'response': response, 'conversation': session['counseling_greeting']})
+
+@app.route('/medication_info', methods=['POST'])
+def medication_info():
+    data = request.get_json()
+    question = data['question']
+    response = generate_response(med_info_model, med_info_tokenizer, f"question: {question}", 'medication_info')
+    return jsonify({'response': response, 'conversation': session['medication_info']})
+
+@app.route('/classify_medication', methods=['POST'])
+def classify_medication():
+    data = pd.DataFrame([request.get_json()])
+    for column in ['Gender', 'Blood Type', 'Medical Condition', 'Test Results']:
+        data[column] = label_encoders[column].transform(data[column])
+    data['Age'] = age_scaler.transform(data[['Age']])
+    predictions = knn_model.predict(data)
+    predicted_medications = medication_encoder.inverse_transform(predictions)
+    if 'classify_medication' not in session:
+        session['classify_medication'] = []
+    session['classify_medication'].append({'user': data.to_dict(), 'bot': predicted_medications[0]})
+    return jsonify({'medication': predicted_medications[0], 'conversation': session['classify_medication']})
+
+
+if __name__ == '__main__':
+    app.run(debug=True)

counseling_model.py

@@ -0,0 +1,46 @@
+from transformers import T5Tokenizer, TFT5ForConditionalGeneration
+import tensorflow as tf
+
+# Load the model and tokenizer
+model = TFT5ForConditionalGeneration.from_pretrained('models\\counsel_model\\saved_model')
+tokenizer = T5Tokenizer.from_pretrained('models\\counsel_model\\tokenizer')
+
+def generate_answer(question):
+    input_text = f"question: {question}"
+    encoding = tokenizer(
+        input_text,
+        max_length=500,
+        padding='max_length',
+        truncation=True,
+        return_tensors='tf'
+    )
+
+    input_ids = encoding['input_ids']
+    attention_mask = encoding['attention_mask']
+
+    generated_text = ""
+    max_length = 512
+    current_input_ids = input_ids
+
+    while True:
+        outputs = model.generate(
+            input_ids=current_input_ids,
+            attention_mask=attention_mask,
+            max_length=max_length,
+            num_beams=5,
+            early_stopping=True,
+            no_repeat_ngram_size=2,
+            return_dict_in_generate=True,
+            output_scores=True
+        )
+
+        text = tokenizer.decode(outputs.sequences[0], skip_special_tokens=True)
+        generated_text += text
+
+        if len(text.split()) < max_length:
+            break
+
+        current_input_ids = tokenizer.encode(text, return_tensors='tf')
+        attention_mask = tf.ones_like(current_input_ids)
+
+    return generated_text

greet_counsel.py

@@ -0,0 +1,62 @@
+from transformers import T5Tokenizer, TFT5ForConditionalGeneration, AutoTokenizer, TFAutoModelForSeq2SeqLM
+import tensorflow as tf
+
+# Load both models and tokenizers
+model1 = TFT5ForConditionalGeneration.from_pretrained('models\\counsel_model\\saved_model')
+tokenizer1 = T5Tokenizer.from_pretrained('models\\counsel_model\\tokenizer')
+
+model2 = TFAutoModelForSeq2SeqLM.from_pretrained('models\\greeting_model\\saved_model')
+tokenizer2 = AutoTokenizer.from_pretrained('models\\greeting_model\\saved_model')
+
+def ensemble_generate(question):
+    # Prepare the input for Model 1
+    input_text1 = f"question: {question}"
+    encoding1 = tokenizer1(
+        input_text1,
+        max_length=500,
+        padding='max_length',
+        truncation=True,
+        return_tensors='tf'
+    )
+
+    input_ids1 = encoding1['input_ids']
+    attention_mask1 = encoding1['attention_mask']
+
+    # Generate output from Model 1
+    outputs1 = model1.generate(
+        input_ids=input_ids1,
+        attention_mask=attention_mask1,
+        max_length=512,
+        num_beams=5,
+        early_stopping=True,
+        no_repeat_ngram_size=2,
+        return_dict_in_generate=True,
+        output_scores=True
+    )
+
+    generated_text1 = tokenizer1.decode(outputs1.sequences[0], skip_special_tokens=True)
+
+    # Prepare the input for Model 2
+    input_ids2 = tokenizer2.encode(question, return_tensors='tf')
+
+    # Generate output from Model 2
+    outputs2 = model2.generate(input_ids2, max_length=500, num_beams=4, early_stopping=True)
+    generated_text2 = tokenizer2.decode(outputs2[0], skip_special_tokens=True)
+
+    # Ensemble strategy: Simple concatenation of both responses
+    final_response = f"Model 1 Response: {generated_text1}\nModel 2 Response: {generated_text2}"
+
+    return final_response
+
+# Test the ensemble with some questions
+test_questions = [
+    'What does it mean to have a mental illness?',
+    'What are some of the warning signs of mental illness?',
+    'What is the Information Technology syllabus?',
+    'How are you? How is your day?',
+    'Is anyone there?',
+]
+
+for question in test_questions:
+    print(f"Question: {question}")
+    print(f"Ensembled Answer: {ensemble_generate(question)}\n")

greeting_model.py

@@ -0,0 +1,18 @@
+import tensorflow as tf
+from transformers import AutoTokenizer, TFAutoModelForSeq2SeqLM
+
+# Load the fine-tuned model and tokenizer
+model = TFAutoModelForSeq2SeqLM.from_pretrained('models\\greeting_model\\saved_model')
+tokenizer = AutoTokenizer.from_pretrained('models\\greeting_model\\saved_model')
+
+def generate_response(input_text, max_length=500):
+    # Tokenize the input text
+    input_ids = tokenizer.encode(input_text, return_tensors='tf')
+    
+    # Generate the response from the model
+    outputs = model.generate(input_ids, max_length=max_length, num_beams=4, early_stopping=True)
+    
+    # Decode the generated tokens back to text
+    decoded_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    return decoded_response

medication_classification_model.py

@@ -0,0 +1,24 @@
+import joblib
+import pandas as pd
+
+def predict_medication(new_data):
+    # Load the model, encoders, and scaler
+    knn = joblib.load('models\\medication_classification_model\\knn_model.pkl')
+    label_encoders = joblib.load('models\\medication_classification_model\\label_encoders.pkl')
+    age_scaler = joblib.load('models\\medication_classification_model\\age_scaler.pkl')
+    medication_encoder = joblib.load('models\\medication_classification_model\\medication_encoder.pkl')
+
+    # Encode the new data using the saved label encoders
+    for column in ['Gender', 'Blood Type', 'Medical Condition', 'Test Results']:
+        new_data[column] = label_encoders[column].transform(new_data[column])
+
+    # Normalize the 'Age' column in the new data
+    new_data['Age'] = age_scaler.transform(new_data[['Age']])
+
+    # Make predictions
+    predictions = knn.predict(new_data)
+
+    # Decode the predictions back to the original medication names
+    predicted_medications = medication_encoder.inverse_transform(predictions)
+
+    return predicted_medications

medication_info_model.py

@@ -0,0 +1,46 @@
+from transformers import T5Tokenizer, TFT5ForConditionalGeneration
+import tensorflow as tf
+
+# Load the model and tokenizer
+model = TFT5ForConditionalGeneration.from_pretrained('models\\medication_info_model\\saved_model')
+tokenizer = T5Tokenizer.from_pretrained('models\\medication_info_model\\tokenizer')
+
+def generate_answer(question):
+    input_text = f"question: {question}"
+    encoding = tokenizer(
+        input_text,
+        max_length=1024,
+        padding='max_length',
+        truncation=True,
+        return_tensors='tf'
+    )
+
+    input_ids = encoding['input_ids']
+    attention_mask = encoding['attention_mask']
+
+    generated_text = ""
+    max_length = 1024
+    current_input_ids = input_ids
+
+    while True:
+        outputs = model.generate(
+            input_ids=current_input_ids,
+            attention_mask=attention_mask,
+            max_length=max_length,
+            num_beams=5,
+            early_stopping=True,
+            no_repeat_ngram_size=2,
+            return_dict_in_generate=True,
+            output_scores=True
+        )
+
+        text = tokenizer.decode(outputs.sequences[0], skip_special_tokens=True)
+        generated_text += text
+
+        if len(text.split()) < max_length:
+            break
+
+        current_input_ids = tokenizer.encode(text, return_tensors='tf')
+        attention_mask = tf.ones_like(current_input_ids)
+
+    return generated_text

requirements.txt

@@ -0,0 +1,5 @@
+Flask
+transformers
+tensorflow
+numpy
+sqlite3