def test_integration_torch_conversation_encoder_decoder(self):
# When
tokenizer = AutoTokenizer.from_pretrained(
"facebook/blenderbot_small-90M")
model = AutoModelForSeq2SeqLM.from_pretrained(
"facebook/blenderbot_small-90M")
nlp = ConversationalPipeline(model=model,
tokenizer=tokenizer,
device=DEFAULT_DEVICE_NUM)
conversation_1 = Conversation("My name is Sarah and I live in London")
conversation_2 = Conversation(
"Going to the movies tonight, What movie would you recommend? ")
# Then
self.assertEqual(len(conversation_1.past_user_inputs), 0)
self.assertEqual(len(conversation_2.past_user_inputs), 0)
# When
result = nlp([conversation_1, conversation_2],
do_sample=False,
max_length=1000)
# Then
self.assertEqual(result, [conversation_1, conversation_2])
self.assertEqual(len(result[0].past_user_inputs), 1)
self.assertEqual(len(result[1].past_user_inputs), 1)
self.assertEqual(len(result[0].generated_responses), 1)
self.assertEqual(len(result[1].generated_responses), 1)
self.assertEqual(result[0].past_user_inputs[0],
"My name is Sarah and I live in London")
self.assertEqual(
result[0].generated_responses[0],
"hi sarah, i live in london as well. do you have any plans for the weekend?",
)
self.assertEqual(
result[1].past_user_inputs[0],
"Going to the movies tonight, What movie would you recommend? ")
self.assertEqual(
result[1].generated_responses[0],
"i don't know... i'm not really sure. what movie are you going to see?"
)
# When
conversation_1.add_user_input("Not yet, what about you?")
conversation_2.add_user_input("What's your name?")
result = nlp([conversation_1, conversation_2],
do_sample=False,
max_length=1000)
# Then
self.assertEqual(result, [conversation_1, conversation_2])
self.assertEqual(len(result[0].past_user_inputs), 2)
self.assertEqual(len(result[1].past_user_inputs), 2)
self.assertEqual(len(result[0].generated_responses), 2)
self.assertEqual(len(result[1].generated_responses), 2)
self.assertEqual(result[0].past_user_inputs[1],
"Not yet, what about you?")
self.assertEqual(
result[0].generated_responses[1],
"i don't have any plans yet. i'm not sure what to do yet.")
self.assertEqual(result[1].past_user_inputs[1], "What's your name?")
self.assertEqual(
result[1].generated_responses[1],
"i don't have a name, but i'm going to see a horror movie.")
def test_integration_torch_conversation(self):
# When
nlp = pipeline(task="conversational", device=DEFAULT_DEVICE_NUM)
conversation_1 = Conversation(
"Going to the movies tonight - any suggestions?")
conversation_2 = Conversation("What's the last book you have read?")
# Then
self.assertEqual(len(conversation_1.past_user_inputs), 0)
self.assertEqual(len(conversation_2.past_user_inputs), 0)
# When
result = nlp([conversation_1, conversation_2],
do_sample=False,
max_length=1000)
# Then
self.assertEqual(result, [conversation_1, conversation_2])
self.assertEqual(len(result[0].past_user_inputs), 1)
self.assertEqual(len(result[1].past_user_inputs), 1)
self.assertEqual(len(result[0].generated_responses), 1)
self.assertEqual(len(result[1].generated_responses), 1)
self.assertEqual(result[0].past_user_inputs[0],
"Going to the movies tonight - any suggestions?")
self.assertEqual(result[0].generated_responses[0], "The Big Lebowski")
self.assertEqual(result[1].past_user_inputs[0],
"What's the last book you have read?")
self.assertEqual(result[1].generated_responses[0], "The Last Question")
# When
conversation_2.add_user_input("Why do you recommend it?")
result = nlp(conversation_2, do_sample=False, max_length=1000)
# Then
self.assertEqual(result, conversation_2)
self.assertEqual(len(result.past_user_inputs), 2)
self.assertEqual(len(result.generated_responses), 2)
self.assertEqual(result.past_user_inputs[1],
"Why do you recommend it?")
self.assertEqual(result.generated_responses[1], "It's a good book.")
def test_integration_torch_conversation_truncated_history(self):
# When
nlp = pipeline(task="conversational",
min_length_for_response=24,
device=DEFAULT_DEVICE_NUM)
conversation_1 = Conversation(
"Going to the movies tonight - any suggestions?")
# Then
self.assertEqual(len(conversation_1.past_user_inputs), 0)
# When
result = nlp(conversation_1, do_sample=False, max_length=36)
# Then
self.assertEqual(result, conversation_1)
self.assertEqual(len(result.past_user_inputs), 1)
self.assertEqual(len(result.generated_responses), 1)
self.assertEqual(result.past_user_inputs[0],
"Going to the movies tonight - any suggestions?")
self.assertEqual(result.generated_responses[0], "The Big Lebowski")
# When
conversation_1.add_user_input("Is it an action movie?")
result = nlp(conversation_1, do_sample=False, max_length=36)
# Then
self.assertEqual(result, conversation_1)
self.assertEqual(len(result.past_user_inputs), 2)
self.assertEqual(len(result.generated_responses), 2)
self.assertEqual(result.past_user_inputs[1], "Is it an action movie?")
self.assertEqual(result.generated_responses[1], "It's a comedy.")
def test_integration_torch_conversation(self):
conversation_agent = self.get_pipeline()
conversation_1 = Conversation(
"Going to the movies tonight - any suggestions?")
conversation_2 = Conversation("What's the last book you have read?")
self.assertEqual(len(conversation_1.past_user_inputs), 0)
self.assertEqual(len(conversation_2.past_user_inputs), 0)
with self.assertLogs("transformers", level="WARNING") as log:
result = conversation_agent([conversation_1, conversation_2],
max_length=48)
self.assertEqual(len(log.output), 2)
self.assertIn(
"You might consider trimming the early phase of the conversation",
log.output[0])
self.assertIn("Setting `pad_token_id`", log.output[1])
# Two conversations in one pass
self.assertEqual(result, [conversation_1, conversation_2])
self.assertEqual(
result,
[
Conversation(
None,
past_user_inputs=[
"Going to the movies tonight - any suggestions?"
],
generated_responses=["L"],
),
Conversation(
None,
past_user_inputs=["What's the last book you have read?"],
generated_responses=["L"]),
],
)
# One conversation with history
conversation_2.add_user_input("Why do you recommend it?")
with self.assertLogs("transformers", level="WARNING") as log:
result = conversation_agent(conversation_2, max_length=64)
self.assertEqual(len(log.output), 3)
self.assertIn("Cutting history off because it's too long",
log.output[0])
self.assertIn(
"You might consider trimming the early phase of the conversation",
log.output[1])
self.assertIn("Setting `pad_token_id`", log.output[2])
self.assertEqual(result, conversation_2)
self.assertEqual(
result,
Conversation(
None,
past_user_inputs=[
"What's the last book you have read?",
"Why do you recommend it?"
],
generated_responses=["L", "L"],
),
)
def customConversation():
customConv_input = input(">> ")
customConv = Conversation(customConv_input)
conversational_pipeline([customConv])
while customConv_input != "bye":
print(customConv)
customConv_input = input(">> ")
customConv.add_user_input(customConv_input)
conversational_pipeline([customConv])
def run_pipeline_test(self, model, tokenizer, feature_extractor):
conversation_agent = ConversationalPipeline(model=model, tokenizer=tokenizer)
# Simple
outputs = conversation_agent(Conversation("Hi there!"))
self.assertEqual(outputs, Conversation(past_user_inputs=["Hi there!"], generated_responses=[ANY(str)]))
# Single list
outputs = conversation_agent([Conversation("Hi there!")])
self.assertEqual(outputs, Conversation(past_user_inputs=["Hi there!"], generated_responses=[ANY(str)]))
# Batch
conversation_1 = Conversation("Going to the movies tonight - any suggestions?")
conversation_2 = Conversation("What's the last book you have read?")
self.assertEqual(len(conversation_1.past_user_inputs), 0)
self.assertEqual(len(conversation_2.past_user_inputs), 0)
outputs = conversation_agent([conversation_1, conversation_2])
self.assertEqual(outputs, [conversation_1, conversation_2])
self.assertEqual(
outputs,
[
Conversation(
past_user_inputs=["Going to the movies tonight - any suggestions?"],
generated_responses=[ANY(str)],
),
Conversation(past_user_inputs=["What's the last book you have read?"], generated_responses=[ANY(str)]),
],
)
# One conversation with history
conversation_2.add_user_input("Why do you recommend it?")
outputs = conversation_agent(conversation_2)
self.assertEqual(outputs, conversation_2)
self.assertEqual(
outputs,
Conversation(
past_user_inputs=["What's the last book you have read?", "Why do you recommend it?"],
generated_responses=[ANY(str), ANY(str)],
),
)
with self.assertRaises(ValueError):
conversation_agent("Hi there!")
with self.assertRaises(ValueError):
conversation_agent(Conversation())
# Conversation have been consumed and are not valid anymore
# Inactive conversations passed to the pipeline raise a ValueError
with self.assertRaises(ValueError):
conversation_agent(conversation_2)
def test_integration_torch_conversation(self):
conversation_agent = self.get_pipeline()
conversation_1 = Conversation(
"Going to the movies tonight - any suggestions?")
conversation_2 = Conversation("What's the last book you have read?")
self.assertEqual(len(conversation_1.past_user_inputs), 0)
self.assertEqual(len(conversation_2.past_user_inputs), 0)
result = conversation_agent([conversation_1, conversation_2],
max_length=48)
# Two conversations in one pass
self.assertEqual(result, [conversation_1, conversation_2])
self.assertEqual(
result,
[
Conversation(
None,
past_user_inputs=[
"Going to the movies tonight - any suggestions?"
],
generated_responses=["L"],
),
Conversation(
None,
past_user_inputs=["What's the last book you have read?"],
generated_responses=["L"]),
],
)
# One conversation with history
conversation_2.add_user_input("Why do you recommend it?")
result = conversation_agent(conversation_2, max_length=64)
self.assertEqual(result, conversation_2)
self.assertEqual(
result,
Conversation(
None,
past_user_inputs=[
"What's the last book you have read?",
"Why do you recommend it?"
],
generated_responses=["L", "L"],
),
)
# if USE_GPU:
# import tensorflow as tf
# physical_devices = tf.config.list_physical_devices('GPU')
# tf.config.experimental.set_memory_growth(physical_devices[0]), True)
from transformers import pipeline, Conversation, GPT2TokenizerFast, GPT2LMHeadModel
tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2",
pad_token_id=tokenizer.eos_token_id)
conversational_pipeline = pipeline("conversational")
######vConversationv#######
conv1_start = "Let's watch a movie tonight, any recommendations?"
conv1 = Conversation(conv1_start)
conversational_pipeline([conv1])
conv1_next = "What is it about?"
conv1.add_user_input(conv1_next)
conversational_pipeline([conv1])
while conv1_next != "bye":
print(conv1)
conv1_next = input()
conv1.add_user_input(conv1_next)
print(conversational_pipeline([conv1]))
BlenderbotTokenizer,
)
if __name__ == "__main__":
import logging
logger = logging.getLogger("transformers").setLevel(logging.CRITICAL)
model = BlenderbotForConditionalGeneration.from_pretrained(
"facebook/blenderbot-400M-distill")
tokenizer = BlenderbotTokenizer.from_pretrained(
"facebook/blenderbot-400M-distill")
convo = ConversationalPipeline(model=model,
tokenizer=tokenizer,
min_length_for_response=0,
framework="pt")
ipt = input(">>> ")
dialogue = Conversation(ipt)
while True:
try:
convo(dialogue, num_beams=3, min_length=0, temperature=1.5)
print(dialogue.generated_responses[-1][1:])
dialogue.add_user_input(input(">>> "))
truncate_convo_to_token_limit(dialogue)
except KeyboardInterrupt:
break
print("\n------Dialogue Summary------")
print(dialogue)
