---
license: apache-2.0
datasets:
- rajpurkar/squad
- ehovy/race
- mandarjoshi/trivia_qa
language:
- vi
- en
library_name: transformers
base_model:
- google-t5/t5-small
pipeline_tag: question-answering
tags:
- code
---
```python
!pip install flask transformers  pyngrok --quiet   # install library

from flask import Flask, request, jsonify
from transformers import T5Tokenizer, T5ForConditionalGeneration
import tensorflow
from pyngrok import ngrok
import json
import torch
import requests
# format output json
def parse_questions(raw_json):
    import re
    questions = []
    question_blocks = re.split(r"Q:\s", raw_json["generated_text"])
    for idx, block in enumerate(question_blocks[1:], start=1):  # Skip the first part of the question
        try:
            question_match = re.search(r"(.+?)\sA:", block)
            options_match = re.search(r"A:\s(.+?)\sCorrect:", block, re.DOTALL)
            correct_match = re.search(r"Correct:\s(.+)", block)

            question = question_match.group(1).strip() if question_match else None
            options_raw = options_match.group(1).strip() if options_match else None
            correct_answer = correct_match.group(1).strip() if correct_match else None


            options = {}
            if options_raw:
                option_list = re.split(r"\d\)", options_raw)
                for i, option in enumerate(option_list[1:], start=1): 
                    options[chr(64 + i)] = option.strip()

            questions.append({
                "id": f"Q{idx}",
                "Question": question,
                "options": options,
                "correct_answer": correct_answer
            })
        except Exception as e:
            print(f"Error parsing block {idx}: {e}")

    return questions

app = Flask(__name__)
ngrok.set_auth_token("Ngrok_Auth_Token")
public_url = ngrok.connect(5000)
print("Ngrok URL:", public_url)

model_name = "TranVanTri352/MCQ_Paragraph_AI_Model"
tokenizer = T5Tokenizer.from_pretrained(model_name)
model = T5ForConditionalGeneration.from_pretrained(model_name, from_tf=True)


@app.route('/status', methods=['GET'])
def model_status():
    try:
        # Check if the model is loaded
        if model and tokenizer:
            return jsonify({
                'status': 'ready',
                'model_name': model_name,
                'framework': 'transformers',
                'device': 'cuda' if torch.cuda.is_available() else 'cpu',
                'message': 'Model is loaded and ready for inference.'
            }), 200
        else:
            return jsonify({
                'status': 'not_ready',
                'message': 'Model or tokenizer is not loaded.'
            }), 500
    except Exception as e:
        return jsonify({
            'status': 'error',
            'message': f'Error occurred while checking model status: {str(e)}'
        }), 500



@app.route('/generate', methods=['POST'])
def generate_text():
    try:
        data = request.json
        if not data or 'text' not in data:
            return jsonify({'error': 'Invalid input, "text" is required'}), 400

        input_text = "Generate a question and multiple answers based on this article: " + data['text']
        inputs = tokenizer(input_text, return_tensors="pt", truncation=True, max_length=512)

        all_outputs = []

        # Loop to generate 5 outputs
        for i in range(5):
            torch.manual_seed(i)  # Set different seeds to increase randomness
            outputs = model.generate(
                input_ids=inputs["input_ids"],
                attention_mask=inputs["attention_mask"],
                max_length=128,
                do_sample=True,  # Turn on random mode
                temperature=0.9,  # Increase randomness
                top_k=30,         # Choose only the word with the highest probability in the top 30
                top_p=0.9,        # Nucleus sampling
                repetition_penalty=1.5,  # Limit repetition
            )
            output_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
            all_outputs.append(output_text) 

     
        final_output = " ".join(all_outputs)

        # Parse the final output into formatted questions
        parsed_questions = parse_questions({"generated_text": final_output})
        json_data = json.dumps(parsed_questions)
        
       

        return jsonify({'questions': parsed_questions}), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/health', methods=['GET'])
def health_check():
    return jsonify({'status': 'Service is healthy'}), 200

print(f"Public URL: {public_url}")

# Flask
if __name__ == "__main__":
    app.run(debug=False)
```

#Test Result
#Request /generate 
```json
{
    "text": "Originally from Gangseo District, Seoul, Faker was signed by SKT in 2013, and quickly established himself as one of the league's top players. In his debut year, he achieved both an LCK title and a World Championship victory with SKT. From 2014 to 2017, Faker added five more LCK titles to his name, along with two MSI titles in 2016 and 2017, and two additional World Championships in 2015 and 2016. During this time, he also emerged victorious in the All-Star Paris 2014 and the IEM World Championship in 2016. Between 2019 and 2022, Faker secured four more LCK titles, becoming the first player to reach a total of 10. He also represented the South Korean national team at the 2018 Asian Games, earning a silver medal, and the 2022 Asian Games, earning a gold."
}
```