This content originally appeared on DEV Community and was authored by Jean Pier Elias
Generative chatbots are revolutionizing human-computer interaction by allowing machines to not only respond to predefined commands but also generate contextually relevant and coherent responses. This technological advancement has found applications in a variety of sectors, from online customer service to virtual assistance on educational and business platforms. The ability of chatbots to understand natural language and generate near-human responses is transforming the way we interact with technology, offering scalable and efficient solutions for automated communication
Chatbot implementation in Flask
Initial configuration:
In this snippet, the necessary libraries are imported and the GPT-2 model and tokenizer are loaded.
from flask import Flask, request, jsonify
from transformers import GPT2LMHeadModel, GPT2Tokenizer
print("Starting application...")
app = Flask(__name__)
# Cargar el modelo y el tokenizer
print("Loading model and tokenizer...")
tokenizer = GPT2Tokenizer.from_pretrained("distilgpt2")
model = GPT2LMHeadModel.from_pretrained("distilgpt2")
print("Model and tokenizer loaded.")
- Flask and other libraries are imported to configure the web server.
- GPT2LMHeadModel and GPT2Tokenizer are imported from transformers to load the GPT-2 model and its tokenizer.
- A Flask instance (app) is initialized to create the web application.
Function to generate responses:
This snippet defines the generate_response function that uses the GPT-2 model to generate responses based on a given prompt.
def generate_response(prompt):
print(f"Generating response for prompt: {prompt}")
inputs = tokenizer.encode(prompt, return_tensors="pt")
outputs = model.generate(
inputs,
max_length=50,
num_beams=5,
early_stopping=True,
no_repeat_ngram_size=2,
temperature=0.7,
top_k=50,
top_p=0.95
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"Generated response: {response}")
return response
- generate_response takes a prompt as input and encodes it using the tokenizer.
- model.generate generates a response based on the prompt using parameters such as max_length to limit the length, num_beams to improve quality, temperature to control creativity, among others.
- The result is decoded using the tokenizer to obtain the final response. Flask API for the chatbot:
In this snippet, we configure a POST /chatbot route that accepts JSON requests with a prompt, generates a response using the generate_response function, and returns the generated response as JSON.
@app.route('/chatbot', methods=['POST'])
def chatbot():
try:
print("Received request.")
body = request.get_json()
prompt = body.get('prompt', '')
response = generate_response(prompt)
return jsonify({'response': response})
except Exception as e:
print(f"Error: {str(e)}")
return jsonify({'message': 'Internal server error', 'error': str(e)}), 500
if __name__ == '__main__':
print("Starting Flask server...")
app.run(debug=True)
- @app.route('/chatbot', methods=['POST']) defines a /chatbot route that accepts POST methods to receive JSON requests.
- chatbot() is the function that handles POST requests, gets the JSON request body prompt, generates a response using generate_response, and returns the generated response as JSON.
- In case of errors, they are captured and handled by returning an error message with status code 500.
Testing with CURL
- First question:
curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"Can you tell me about the weather today?\"}"
- Second question:
curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"hello?\"}""
- Third question:
curl -X POST http://127.0.0.1:5000/chatbot -H "Content-Type: application/json" -d "{\"prompt\": \"how are you?\"}"
Next Steps:
We should always try to deploy this type of projects in the cloud, whether AWS or Azure, in this case I leave an illustrative diagram of what the deployment would look like using AWS lambda, AWS Api Gateway and AWS S3.
Conclusion:
The combination of GPT-2 and Flask allows the development of chatbots for educational purposes, capable of dealing naturally and effectively with users. These technological advances are rapidly transforming how we think about human-computer interaction, offering scalable and efficient solutions for a variety of applications, from customer service to AI-assisted education, as long as we use the most advanced models such as GPT-4 or GPT. -4o. As we continue to explore and refine these tools, it's clear that generative chatbots represent a significant step toward smarter, more adaptive systems in the digital future.
This content originally appeared on DEV Community and was authored by Jean Pier Elias
Jean Pier Elias | Sciencx (2024-07-09T11:36:00+00:00) Creating a Generative AI Chatbot using GPT-2 and Flask. Retrieved from https://www.scien.cx/2024/07/09/creating-a-generative-ai-chatbot-using-gpt-2-and-flask-2/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.