Video Summarizer GPT

Act as a summarizer. You will summarize the transcript of an online course. I will provide you the transcript of the online course. Because the transcript could be very long, I may break the section into pieces and feed to you one by one. 

The summarize should be comprehensive and concise. It should be understandable by 17 year old teenager. Some of the formatting tips:
Highlight important works/lines in bold.
Use third party tone. 

{Your Transcript to summarize:One of the exciting things about a large  language model is you can use it to build a custom chatbot  with only a modest amount of effort. ChatGPT, the web interface,  is a way for you to have a conversational interface,  a conversation via a large language model. But one of the  cool things is you can also use a large language model to  build your custom chatbot to maybe play the role of an AI  customer service agent or an AI order taker for a restaurant.  And in this video, you learn how to do that for yourself.  I'm going to describe the components of  the OpenAI ChatCompletions format in more  detail, and then you're going to build a chatbot yourself. So let's  get into it. So first, we'll set up the OpenAI Python package as  usual.  So chat models like ChatGPT are actually trained  to take a series of messages as input  and return a model-generated message as output. And  so although the chat format is designed to make multi-turn conversations  like this easy, we've kind of seen through the previous videos  that it's also just as useful for single-turn tasks without any conversation.  And so next, we're going to kind of define two helper functions. So  this is the one that we've been using throughout all the videos,  and it's the getCompletion function. But if you kind  of look at it, we give a prompt, but then kind of  inside the function, what we're actually doing is putting this prompt  into what looks    like some kind of user message. And this is because the  ChatGPT model is a chat model, which means it's trained to take a series  of messages as input and then return a model-generated message  as output. So the user message is kind of the input, and  then the assistant message is the output.  So, in this video, we're going to actually use  a different helper function, and instead of kind of  putting a single prompt as input and getting  a single completion, we're going to pass in a list of messages. And these  messages can be kind of from a variety  of different roles, so I'll describe those. So here's an example of  a list of messages. And so, the first message is  a system message, which kind of gives an overall instruction, and then after  this message, we have kind of  turns between the user and the assistant. And this would kind  of continue to go on. And if you've ever used ChatGPT, the  web interface, then  your messages are the user messages, and then ChatGPT's  messages are the assistant messages. So the system message helps  to kind of set the behaviour and persona  of the assistant, and it acts as kind of a high-level instruction  for the conversation. So you can kind of think of it as whispering  in the assistant's ear and kind of guiding it's responses without the  user being aware of the system message. So, as the user, if  you've ever used ChatGPT, you probably don't know what's  in ChatGPT's system message, and that's kind of the intention. The benefit  of the system message is that it provides you, the developer, with  a way to kind of frame the conversation without making the  request itself part of the conversation. So you can  kind of guide the assistant and kind of whisper in  its ear and guide its responses without making the user aware.    So, now let's try to use these messages in a conversation.  So we'll use our new helper function to get the  completion from the messages.  And we're also using a higher temperature.  So the system message says, you are an assistant  that speaks like Shakespeare. So this is us kind of describing to  the assistant how it should behave. And then the first user message is,  tell me a joke. The next is, why did the chicken cross the road?  And then the final user message is, I don't know.  So if we run this,  the response is to get to the other side. Let's try again.  To get to the other side, faire so, madame,  tis an olden classic that never fails. So there's  our Shakespearean response.  And let's actually try one more thing, because  I want to make it even clearer that  this is the assistant message. So here, let's just  go and print the  entire message response.  So, just to make this even clearer, uhm, this  response is an assistant message. So, the role is assistant  and then the content is the message itself. So, that's  what's happening in this helper function. We're just  kind of passing out the content of the message.  now let's do another example. So, here our messages are, uhm, the  assistant message is, you're a friendly chatbot and the first  user message is, hi, my name is Isa. And we want to, uhm,    get the first user message. So, let's execute this. The  first assistant message.  And so, the first message is, hello Isa, it's nice to meet you. How  can I assist you today?  Now, let's try another example.  So, here our messages are, uhm, system message, you're  a friendly chatbot and the first user message is, yes,  can you remind me  what is my name? And let's get the response.  And as you can see,  the model doesn't actually know my name.  So, each conversation with a language model is a standalone  interaction which means that you must provide all relevant  messages for the model to draw from in the current conversation.  If you want the model to draw from or, quote unquote,  remember earlier parts of a conversation,  you must provide the earlier exchanges in the  input to the model. And so, we'll refer to this as context. So, let's  try this.  So, now we've kind of given the context that the model needs, uhm, which  is my name in the previous messages and we'll ask  the same question, so we'll ask what my name is.  And the model is able to respond because it has  all of the context it needs, uhm, in this kind of list of  messages that we input to it.  So now you're going to build your own chatbot.  This chatbot is going to be called orderbot, and  we're going to automate the collection of  user prompts and assistant responses in order to build  this orderbot. And it's going to take orders at a pizza restaurant, so  first we're going to define this helper function, and what this  is doing is it's going to kind of collect our user messages  so we can avoid typing them in by hand in  the same, in the way that we did above, and this is going  to kind of collect prompts from a user  interface that will build below, and then append it  to a list called context, and then it will call the model with  that context every time. And the model response  is then also added to the context, so the kind of    model message is added to the context, the user message is  added to the context, so on, so it just kind of grows longer and  longer.  This way the model has the information it needs to  determine what to do next. And so now we'll  set up and run this kind of UI to display the order bot, and  so here's the context, and it contains the system message that  contains the menu,  and note that every time we call the language model we're  going to use the same context, and the context is building  up over time.  And then let's execute this.  Okay, I'm going to say, hi, I would like to order a pizza.  And the assistant says, great, what pizza would you like to order?  We have pepperoni, cheese, and eggplant pizza.  How much are they?  Great, okay, we have the prices.  I think I'm feeling a medium eggplant pizza.  So as you can imagine, we could kind of continue this conversation,  and let's kind of look at what we've put in the system message.  So you are order bot, an automated service  to collect orders for a pizza restaurant.  You first greet the customer, then collect the order,  and then ask if it's a pickup or delivery. You  wait to collect the entire order, then summarize it and check  for a final time if the customer wants  to add anything else. If it's a delivery, you can  ask for an address. Finally, you collect the payment. Make sure  to clarify all options, extras, and sizes  to uniquely identify the item from the menu. You respond  in a short, very conversational, friendly style.  The menu includes, and then here we have the menu.  So let's go back to our conversation and let's see  if the assistant kind of has been following the instructions.  Okay, great, the assistant asks if we want any toppings  which we kind of specified an assistant message.  So I think we want no extra toppings.  Things... sure thing. Is there anything else we'd  like to order? Hmm,  let's get some water. Actually,  fries.  Small or large? And this is great because we kind of  asked the assistant in the system message to  kind of clarify extras and sides.  And so you get the idea and please feel free  to play with this yourself. You can pause the video and just go  ahead and run this in your own notebook on the left.  And so now we can ask the model to create a JSON  summary that we could send to the order  system based on the conversation.  So we're now appending another system message which is an  instruction and we're saying create a JSON summary of  the previous food order, itemize the price for each item, the fields  should be one pizza, include side,  two lists of toppings, three lists of drinks,  and four lists of sides, and finally the total price.  And you could also  use a user message here, this does not have to be a system  message.  So let's execute this.  And notice in this case we're using a lower  temperature because for these kinds of tasks we want  the output to be fairly predictable. For  a conversational agent you might want to use  a higher temperature, however in this case I  would maybe use a lower temperature as well  because for a customer's assistant chatbot you might want  the output to be a bit more predictable as well.  And so here we have the summary of our order and so  we could submit this to the order system if we wanted to.  So there we have it, you've built your very own order chatbot. Feel  free to kind of customize it yourself and play around with the  system message to kind of change the behavior of the chatbot and  kind of get it to act as different personas  with different knowledge. }