Full Video:
Model Updates & Features
What are the main features of GPT-4 Turbo 0.1?
A: GPT-4 Turbo 0.1 includes function calling, structured outputs with JSON schema support, developer messages (new version of system messages), reasoning effort parameter, and vision inputs support. It uses 60% fewer thinking tokens than the preview version. The model shows significantly better performance in function calling, structured outputs, and coding compared to GPT-4.
How does the reasoning effort parameter work?
A: The reasoning effort parameter allows developers to control how much time the model spends thinking about problems. It helps save time and money on simpler problems while allocating more compute power to complex tasks that require deeper thinking. This feature enables more efficient resource utilization based on task complexity.
What is the difference between developer messages and system messages?
A: Developer messages are a new spin on system messages and are part of the instruction hierarchy work. They are controlled entirely by the developer to steer the model and help teach the models which instructions to follow in what order.
What are the internal evaluation results for GPT-4 Turbo 0.1?
A: Internal evaluations show that GPT-4 Turbo 0.1 significantly outperforms GPT-4 in function calling, structured outputs, and coding (shown in LiveBench evaluations). The model maintains its reasoning capabilities even when using structured outputs, and performs better than GPT-4 0.1 preview version.
Technical Integration
How does the new WebRTC support simplify implementation?
A: The new WebRTC support reduces implementation code from 200+ lines to approximately 12 lines of code. It automatically handles internet connectivity issues, provides echo cancellation, and adjusts bitrate automatically. The integration requires only setting up a peer connection and handling audio elements, making it significantly more straightforward than previous websocket implementations.
How does the microcontroller integration work?
A: The microcontroller integration is remarkably simple, requiring only a token and Wi-Fi details to connect. It can be set up in 30-45 minutes without any soldering or complex hardware requirements, using microcontrollers available from major retailers. The demo showed it working with a simple speaker plugged into a headphone jack.
What’s the process for implementing vision inputs?
A: Vision inputs in GPT-4 Turbo 0.1 allow processing of images and can be used for tasks like form error detection, manufacturing, and science applications. The demo showed it successfully analyzing a tax form across multiple pages, detecting calculation errors and incorrect deductions.
What’s the format for preference fine-tuning data?
A: Preference fine-tuning uses a JSONL file format where each example contains input messages, a preferred output, and a non-preferred output. This differs from supervised fine-tuning’s exact input-output pairs format.
Cost & Pricing
What are the new pricing changes?
A: GPT-4 audio tokens are now 60% cheaper than before. GPT-4 mini audio tokens are being offered at 10x cheaper than the current price. The model also uses 60% fewer thinking tokens than the preview version, resulting in additional cost savings.
What cost savings can be achieved with the 60% reduction in thinking tokens?
A:The model also uses 60% fewer thinking tokens than the preview version, resulting in additional cost savings.
What’s the specific pricing comparison between supervised fine-tuning and preference fine-tuning?
A: The pricing for preference fine-tuning is set at the same rate as supervised fine-tuning, making it a cost-neutral choice for developers who want to switch to the new fine-tuning method.
Fine-tuning & Customization
How does preference fine-tuning differ from supervised fine-tuning?
A: Preference fine-tuning uses pairs of responses (preferred vs. non-preferred) instead of exact input-output pairs used in supervised fine-tuning. It focuses on learning user preferences and style differences through Direct Preference Optimization. Early testing shows improved results, with one partner seeing accuracy increase from 75% to over 80%.
What are the specific details about the new hyper-parameters for preference fine-tuning?
A: While the transcript mentions hyper-parameters are available for tuning during the preference fine-tuning process, users can select defaults for simplicity. Unfortunately, specific parameter details weren’t provided in the presentation.
Availability & Access
When will these features be available?
A: The rollout begins with tier 5 customers receiving access to GPT-4 Turbo 0.1 starting immediately, with email notifications being sent. The complete rollout will take a few weeks to reach all customers. GPT-4 Turbo Pro version is confirmed to be in development but doesn’t have a specific release date yet.
What are the specific tier requirements for accessing GPT-4 Turbo 0.1?
A: The rollout begins with tier 5 customers, with access being granted based on usage tiers. Customers will receive email notifications when they get access, with the complete rollout expected to take several weeks.
Developer Resources
What new developer resources are available?
A: OpenAI has released official SDKs for Go and Java with full API endpoint support. Previous Dev Day talks are now available on OpenAI’s YouTube channel for reference. They’ve also simplified the API key acquisition process and are hosting AMAs with presenters on the OpenAI developer forum.
What improvements have been made to the API key acquisition process?
A: The new login/signup flow has been simplified to obtain an API key in seconds, eliminating the need to sign multiple terms of service documents, making it significantly more streamlined for developers.
What are the specific changes to the realtime API’s function calling and guardrails?
A: The realtime API now includes improved support for function calling and guardrails, making it easier to integrate these features, though specific implementation details weren’t provided in the transcript.
What specific features are included in the new Go and Java SDKs?
A: The new Go and Java SDKs provide full API endpoint support similar to the Python and Node SDKs. They are now officially supported by OpenAI and developers are encouraged to provide feedback on their implementation.
How can developers access the previous Dev Day conference content?
A: All previous Dev Day conference talks from around the globe have been released on the OpenAI YouTube channel. These talks contain valuable technical content and implementation guidance from various OpenAI events.
Performance & Limitations
How reliable is the WebRTC implementation?
A: The WebRTC implementation is highly reliable as it was built specifically for internet use. It automatically handles internet connectivity changes, adjusts bitrate as needed, and includes echo cancellation. These features make it more robust than the previous websocket implementation.
What are the performance metrics for different use cases?
A: According to internal evaluations, GPT-4 Turbo 0.1 shows significant improvements over GPT-4: better function calling performance, improved structured outputs, enhanced coding capabilities (shown in LiveBench evaluations), and maintained reasoning capabilities even when using structured outputs. It also uses 60% fewer thinking tokens than the preview version.
How does vision input processing perform in real-world scenarios?
A: The demo showed vision processing successfully handling multiple-page document analysis, cross-referencing information across images, and detecting both arithmetic and logical errors in tax forms. However, the transcript notes it should not be considered a substitute for professional judgment.
What were the specific results from the AMI evaluations?
A: The AMI evaluations showed GPT-4 Turbo 0.1 significantly outperformed the preview version, and importantly, maintained the same level of performance even when using structured outputs, proving that the structured output feature doesn’t compromise reasoning capabilities.
Realtime API Updates
What are the specific use cases for the microcontroller integration?
A: The microcontroller integration can be used for wearable devices like glasses, cameras and microphones around the house, and context-aware assistants. The tiny microcontroller (penny-sized) can be implemented in about 30-45 minutes with just USB connectivity and no soldering required.
What’s the difference between WebSocket and WebRTC implementation for the real-time API?
A: While WebSocket implementation required 200-250 lines of code and manual handling of back pressure and other issues, WebRTC reduces this to about 12 lines of code and automatically handles internet connectivity changes, bit rate adjustments, and echo cancellation, making it significantly easier to implement.
Full Transcript
Day 9 of 12 Days of Open AI Announcements
(00:00) Olivia Gar:
Welcome everyone! I’m Olivia Gar, I lead the platform product at OpenAI. Today is the best day, like, I’m very biased! Today is all about developers and startups building on top of the OpenAI API. Zooming out, we’ve had an API for, what, four years? The scale is incredible: 2 million developers building from more than 200 countries. Pretty cool! And so as a thank you gift, we have several new models and features to announce today to thank you for being a part of the community. So, kind of a small Dev Day, I don’t know, North Pole Santa Edition. So, Michelle, take it away!
(00:33) Michelle Poas:
Thanks! I’m Michelle Poas, and I work on our post-training research team.
(00:37) Brian John:
Hi, I’m Brian John. I’m also on the post-training team at OpenAI.
(00:39) Michelle Poas:
Awesome! Well, like Olivia said, we just cannot stop doing Dev Days! So here’s another small one. Um, today I’m super excited to tell you that we’re launching gpt-4-01 out of preview in the API. Since we announced gpt-4-01 preview in September, developers have been building super cool stuff on the API, you know, agentic applications and customer support or financial analysis. And also, it’s just a phenomenal coding model! So we’ve been really excited to see that. We’ve also heard feedback from developers that you’re missing kind of the core features that you’ve come to expect on our API. And today, we’re launching them in gpt-4-01 in the API. So we’re launching function calling, structured outputs, and developer messages. And uh, developer messages are a little new. They’re a new spin on system messages, and they’re actually part of our instruction hierarchy work to teach the models which kind of instructions to follow in what order. So the developer message is controlled entirely by the developer and used to steer the model. Finally, uh, we’re also launching reasoning effort. This is a new parameter that tells the model how much to spend time thinking. It’s really helpful to save a little time and money on, you know, easier problems, and then you can spend more compute on the hardest problems where you need it. I said finally, but that’s not true! We’re also launching vision inputs in the API. Awesome people have just been really asking for this, and we think it’ll help a lot in cases like manufacturing or science. Um, so super excited to see what you build there, but actually, let’s see a quick demo!
(02:01) Brian John:
All right! Yeah, let’s walk through a live demo to see some of the gpt-4-01’s new capabilities in the API. Uh, starting with vision. So for that, I’ve prepared the photo scans of a text form that I filled out with some fake data the other day, but I had some mistakes in there, and I wonder if gpt-4-01 can help us detect errors in the form. But just a quick note before we get started: while gpt-4-01 can help us detect errors in forms like a text form, it is not a substitute for professional judgment.
(02:32) Michelle Poas:
Of course, of course.
(02:33) Brian John:
All right, I will open up our developer playground, which is a really nice UI for experimenting with OpenAI models in the API. At the top, this is our newly introduced developer message. This is where you can provide the model with some high-level instructions or sometimes detailed instructions on how it should behave as a model. I have a pretty simple one here, and then I uploaded the images from my form and ask the model to spot for errors. While gpt-4-01 is thinking, let’s jump back to my form to take a look at the errors that I had. So the first one that I had, the first error I had is on line 11, for calculating adjusted gross income, AGI, I was supposed to subtract line 10 from line 9, but I did the opposite. I used addition.
(03:18) Michelle Poas:
We’ve all been there.
(03:19) Brian John:
Well, happens! I got a little too excited every time I see the word AGI. The second error is, I use the wrong standard deduction. Looking at the chart on page four, standard deduction depends on both the filing status and also the number of checked boxes on page one. So this means for the, for gpt-4-01 to figure out the correct value for standard deduction, you need to reference content from two other images. Let’s see, let’s see what the model gets back to us. All right, let’s see the model. Great! It noticed the arithmetic error on line 11. Um, I, I was supposed to use subtraction. That’s good. Um, and it also noticed the standard deduction amount is incorrect, which is also right. And based on that, of course, I need to adjust my tax B income and subsequent tax.
(04:27) Brian John:
All right, after fixing those two errors in my form, I know my taxable income now arrives at 9,325. Next up, I will ask the model based on information from the form, how much income tax do I owe if my taxable income is this? So what do you think the model will do here? Really hoping it gives us a good answer.
(04:51) Michelle Poas:
Well, gpt-4-01 doesn’t have access to the latest up-to-date 2024 tax table.
(04:55) Brian John:
But it does have access to a set of functions we provided on the right. Functions are a way for the model to interact with your backend APIs. So here, we can take a look at one of those functions. So we provided, it’s, it’s rendered in a JSON schema, and we provide a high-level description for what the function does and the set of arguments the model needs to provide to call the function.
(05:19) Michelle Poas:
So, this is, our function calling feature.
(05:20) Brian John:
Makes sense. So, the model calls this function. We can call this on the backend, get the correct tax data, send it back.
(05:27) Michelle Poas:
Exactly.
(05:28) Brian John:
Looks like the model called the correct function here, uh, with the input from, pulled from the image. Does, does the user see any of this?
(05:39) Michelle Poas:
Uh, not really. So this all happens in the backend of your app. The user will not see any of the function calls nor the response from your API.
(05:48) Brian John:
So, after we get the response, we will send that back to the model and gpt-4-01 will respond to the user in a very nice looking user message. So here it tells the user about their new updated income tax after the corrections.
(06:04) Michelle Poas:
Awesome!
(06:05) Brian John:
Better! But that’s not all. I wanted to show you one last thing that’s structured outputs. I will ask the model here, what, what corrections do I need in my forms? But before I hit enter, I want to provide model a JSON schema for the response format. This will instruct the model to output according to this JSON schema. And on top of that, we also implemented solutions on the API backend to ensure the model output adhere to this JSON schema 100% of the time.
(06:30) Michelle Poas:
Makes sense.
(06:32) Brian John:
Actually, let’s take a quick look at this schema. So, uh, it’s called “form correction”, and it’s got a list of “corrections”, and each “correction” has what you’d expect. So there’s the reason, so we can display to the user what they got wrong, and then it’s got the location. Um, so this is super cool. We can actually, like, render a UI for the PDF and highlight exactly what’s wrong with the new value and the old value. Um, so structured outputs is super useful when you don’t want to kind of render markdown from the model and you want to just extract the JSON automatically. So, you can see here, the model has output, uh, the corrections, you can see there in the, the nice JSON format. We’ve got the new value, the old value, all locations, and reasons. Um, and so yeah, this is super helpful when you’re building kind of, uh, rich featureful applications. So we just showed you a quick demo, but, uh, you know, demos are really not enough to give you the full story. We actually run internal evaluations, which are like tests to see how our features do before we ship them. Um, and so for gpt-4-01, uh, because it’s really important for developers, we ran some evals for API use cases. So, I’m going to show you a few of these, let’s take a look. Um, first we have function calling. Um, so we have some internal function calling evals, and you can see that, uh, this new gpt-4-01 model is significantly better than GPT-4-0 on function calling. And this actually includes both halves of function calling, you know, calling the right function when you should and not calling a function when you shouldn’t. Um, you can also use function calling in conjunction with structured outputs, and you can see that again, gpt-4-01 performs much better than 4-0 here. Speaking of structured outputs, gpt-4-01 also significantly better on this eval. This means the model does a better job of following the format. Um, so we take it less off distribution when we constrain it.
(08:40) Brian John:
Next is coding. Everyone’s always talking about coding. Um, LiveBench is an open-source coding eval, and we’re excited to see that gpt-4-01 performs, you know, much better than gpt-4-01 preview and 4-0 on this eval.
(08:50) Michelle Poas:
That’s awesome!
(08:51) Brian John:
That’s a huge jump. Yeah. And then, finally, we have Amy. Um, and on this eval, you can see that gpt-4-01 again significantly outperforms gpt-4-01 preview. But actually, the interesting bit here is that we have on the right, gpt-4-01 with structured outputs. So when building structured outputs, we really wanted to make sure the model performs just as well when using structured outputs as without. So you can see that the reasoning capabilities are maintained, even with this feature. So you can use it in your application and not have to worry about the results.
(09:12) Michelle Poas:
Awesome.
(09:14) Brian John:
So those are the evals. But beyond the evals, uh, there’s actually a really interesting change in latency. So gpt-4-01 actually uses 60% fewer thinking tokens than gpt-4-01 preview, which means it’s much faster and cheaper for your application. Finally, we’ve heard a ton of demand from you for gpt-4-01 pro in the API, and I’m sorry to say, we don’t have it now, but our elves are hard at work back at the lab, and it should be coming soon. We’re working very hard, yeah.
(09:41) Michelle Poas:
Cool, awesome.
(09:43) Olivia Gar:
Thank you so much, Brian, Michelle. Um, to recap, gpt-4-01 in the API, function coding, structured output, uh, developer messages, image understanding, will start rolling out to Tier 5 customers starting today. You will receive an email and will take us a few weeks to get to everyone. So, gpt-4-01 is not the only model that we shipped, uh, recently. Uh, we’ve had a lot of excitement on the real-time API. How do you have like natural human-level latency speech application? So, Sean, give us an update.
(10:14) Sean:
Hey, I’m Sean, and I’m here with-
(10:15) Andrew:
I’m Andrew.
(10:15) Sean:
…and I’m here to talk about the real-time API. So, if you’ve never used the real-time API before, it lets you build real-time voice experiences with OpenAI. So, think you can build your own ChatGPT advanced voice mode, you can add AI assistants, you can do all these really cool things with AI. Um, and today, we have WebSocket support, so you can do server-to-server and send voice and get responses back. But today, uh, what we’re announcing is WebRTC support, and that’s really exciting for three reasons. The first is that WebRTC was built for the internet. So, if you’ve done conferencing, if you’ve done low-latency video streaming, that all uses WebRTC. And that handles, you know, the constant changing of the internet. It, it’ll change your bit rate, it will do echo cancellation. And so what’s exciting is now real-time API gets all of these benefits. So, if I build an application, things are way easier, and it just works. So, to leave that in, I’ll show you a little demo application to show you how easy it is to do. So here’s a little HTML, and just to give you a structure of it, we have an audio element, we have a peer connection, and what the peer connection is, it’s kind of the one-to-one connection between you and the real-time API. And so what we’re doing today is we’re creating this peer connection. We’re saying, when the real-time API sends you some audio, put it into that audio element. Next, we capture the microphone, and we’re adding it to the peer connection. So we’re saying we’re going to send one audio stream to OpenAI. And then now that we’ve set up this pier connection, we do an offer answer. And what the offer answer does is it collects up all the information locally, you send it via an HTTP post, post, and we respond. And WebRTC then goes and does everything for you. There’s no handling of, um, congestion control or capturing the audio or any of those other things you had to deal with before.
(12:04) Andrew:
That’s awesome.
(12:04) Andrew:
So, how does that compare to the previous WebSocket integration?
(12:07) Sean:
So if you were doing WebSockets before, this code would probably be between like 200 and 250 lines of code, and, um, you would have additional problems on top of that. Like, you’d have to handle back pressure and all these things. Like, it’s, it’s one of those problems that you don’t realize how frustrating it is until you finally go production.
(12:14) Andrew:
I see.
(12:15) Sean:
So, let’s actually run the code and see what it looks like. So here’s the code, um, my audio element, and I’ll refresh the page.
(12:21) Sean (in demo):
How many days until Christmas?
(12:24) Real-time API response:
Christmas is on December 25th, and today is December 17th. That means there are eight days left until Christmas.
(12:30) Sean:
Nice. Always exciting when a demo works. Okay. So yeah, so that, that’s all it took. Is that, so you just copy-pasted the 12 lines, you execute the script, and that’s it?
(12:41) Andrew:
Yep. And like, we’ll, we’ll open, we’ll put this code out, and so you can just go and grab that. Um, the only thing that you’d have to change is your API token. And so you can go and download this code and run it. Um, I’m really excited to see what people build, like, as we make it way easier.
(12:54) Sean:
Okay, so the next thing I want to talk about, I’m going to have to bring out a little friend. So, I wasn’t able to get an Elf on the Shelf this year, so I got a Fawn on the Lawn! A new official toy. So, Fawn on the, has a microcontroller in it. And to give you a sense of, here it is. And before I plug it in, here’s how big this microcontroller is, um, absolutely tiny, like the size of a penny. So, I’ve got the microcontroller in there, and I’m going to plug it in, and we’ll see what happens.
(13:24) Fawn on the Lawn (Real-time API):
Merry Christmas!
(13:25) Sean:
What are you talking about? We’re talking about adding WebRTC to the real-time API!
(13:29) Fawn on the Lawn (Real-time API):
Oh, that sounds a bit too complicated for me. How about we talk about something more fun, like delivering presents? There’s nothing quite like soaring through the sky to bring joy to everyone on Christmas Eve!
(13:39) Sean:
Okay, what am I getting for Christmas?
(13:40) Fawn on the Lawn (Real-time API):
Oh, I’m not supposed to spoil the surprise, but I think you might be getting something very familiar this year.
(13:44) Sean:
Could it be some coal?
(13:46) Fawn on the Lawn (Real-time API):
Oh, okay, um, cool!
(13:47) Sean:
So, we saw using the real-time API in the reindeer. So, um, but that’s just, like, a, a tip of the iceberg with all the use cases that you can build. So with something this size, you could put it on, you know, a wearable device like glasses, you could put it into, um, cameras and and microphones around the house, you can have like context-aware assistance. Um, like I am so excited for what people build, because with this SDK, all you have to do is set your token and set some details about your Wi-Fi, and it connects. Like, these are microcontrollers that you can get off from like any major retailer. You plug it in USB, and that’s all. Like, I, I really think that 30, you know, 30, 45 minutes, people can start doing the, like building this up. There’s no soldering, there’s no hardware. Um, we just have a speaker plugged into a headphone jack.
(14:42) Andrew:
That’s super cool!
(14:43) Sean:
Super cool. And we have other updates to the real-time API. Number one, we heard your feedback on the cost. We’re dropping the cost! So from now on, GPT-4-0 audio tokens will be 60% cheaper than before. And we are also shipping support for 4-mini in the API, and 4-mini audio tokens will be 10x cheaper than the current price. The second thing is that we’re shipping support for a Python SDK for the time API to make it even easier to integrate. And lastly, we’re making some API changes to make it easier for you to use function coding and guard rails. So all of that we hope, uh, and we cannot wait to see the kind of applications that you’re going to build.
(15:38) Olivia Gar:
All right, we talked about models, we talked about API. Would love to talk about fine-tuning customization. That’s one of the big, like, needs from developers. Like, they want to customize the models for their own use cases. What do you have, Andrew?
(16:03) Andrew:
Yeah, so unfortunately, I don’t have a reindeer to share. That’s fine! But we are excited to announce a new method of fine-tuning available in our API called preference fine-tuning, and we’ll be using a method called direct preference optimization, which is designed to help you create models that better align with user preferences, which should hopefully give increased performance where user feedback plays a critical role.
(16:23) Olivia Gar:
You guys have been shipping a ton. You’re on fire, like, for the past few months. But we’ve had an API for years. What’s new? What’s the difference?
(16:28) Andrew:
Yeah, so currently in our API, we have supervised fine-tuning and the newly announced reinforcement fine-tuning. Most of our users have been using supervised fine-tuning to tailor our models for their use cases. And in supervised fine-tuning, you provide the exact input and output you want the model to have. So if you’re creating a user chatbot, you’d give it the user messages and then the exact response. Um, and preference fine-tuning is a little bit different. So instead of the exact input and output, you’re going to be giving it a pair of responses where one is preferred over the other. And then our fine-tuning process will optimize it to learn the differences in those responses. And those differences could be things like response formatting, stylistic guidelines, or even like abstract qualities, uh, like helpfulness or creativity.
(17:01) Olivia Gar:
I see, I see. So, typical use cases would be what? Customer support? Copywriting? Creative writing?
(17:06) Andrew:
Yeah, exactly. So if you see our models maybe are a little bit too verbose or they’re giving irrelevant answers, um, this fine-tuning can help guide it toward more concise and relevant responses by emphasizing the preferred behavior and then deemphasizing the unpreferred ones. Another really good, uh, use case might be content moderation. So, for example, if you have a specific style or tone you want your organization to have, uh, preference fine-tuning can help guide it toward that. Um, but yeah, let me show you actually how easy it is to start fine-tuning in our API. Um, so here I am on the platform UI, and I’m in the fine-tuning tab. So, when I hit “Create fine-tune”, now you can see that there’s a new drop-down for “method”, and I’m just going to select “direct preference optimization”. Next, I’ll select the base model. Uh, in this case, I’ll select GPT-4-0. And then finally, all I have to do is upload the training data. And like I mentioned before, the format’s a little bit different. So, I’ll go through a quick example. Um, in this example, um, we’re asking an assistant what the weather is like in New York City, and providing it two pairs of responses, like I mentioned. And maybe we’re making a chatbot, so we want to be a bit more conversational. So in the preferred response, it’s a bit more verbose and then also responds in Fahrenheit. And the unpreferred response, it’s much more concise and responds in Celsius. So, I’m going to take these examples, put them in a JSONL file, um, where each example is going to contain the input messages, the preferred output, and then also the non-preferred output. Um, so I’ll go ahead and upload the data now. And we also provide some hyper-parameters to tune, but I will just select the defaults for now and hit “create”. And so this is going to kick off the fine-tuning process. Um, depending on the data set size, this could take anywhere from several minutes to several hours, but once it’s done, we should be able to sample from the model the same way we would any base model in our API.
(18:55) Olivia Gar:
Man, it’s so exciting. So, have you had a chance for people to use it yet?
(18:58) Andrew:
Yeah, so we’ve given early access to preference fine-tuning to several of our trusted partners. Um, and we’ve seen good results so far. So as an example, uh, Rogo AI is building an AI assistant for financial analysts, and they’re using our models to rewrite and refactor user queries, um, to give more relevant answers. When they use, used supervised fine-tuning, they couldn’t quite get it to perform better than the base model. But with preference fine-tuning, they saw accuracy increase on their internal benchmark from 75% at the base model to over 80% with preference fine-tuning. So we’re super excited to see what other developers can do with preference fine-tuning, um, which is why we’re actually going to make this available for GPT-4-0 today, and GPT-4-0 mini soon, um, at the same price per train token as supervised fine-tuning. So if you out there are excited to start preference fine-tuning, I encourage you to check out our documentation later today.
(19:49) Olivia Gar:
That’s awesome! That’s awesome. Okay, there is a lot to unwrap, lots of gifts. We started with gpt-4-01, gpt-4-01 in the API with the full production feature set, such as function coding, that people expect. Starting rolling out to Tier 5 starting today. Um, then we talked about the real-time API, new API, simpler WebRTC integration, and price TP. And now we’re talking preference fine-tuning to make it easier to customize models for your use cases. And that’s not all, the team is non-stop shipping. They shipped a few new things today, and so I wanted to show you a few, uh, smaller things which are coming up. Um, number one is, we cannot talk about the developer experience and product quality. And so we’re going to ship, to announce, uh, starting today, new SDKs. Uh, we have official support for Go and uh, Java SDKs. You can find them here. Uh, please give us feedback similar to the Python SDK, and um, the Node SDK. Um, they support all the API endpoints that you need on OpenAI. So here’s the Go one, and here is the Java one. Um, number two, we care a ton about simplicity. I’m not going to go through the whole flow, but we have a new login, sign up, and flow to get an API key. So there is no need to, whatever, like, you know, sign five terms of services, you get an API key, like, in just a few seconds. Next, we did a bunch of Dev Days around the globe for the past, uh, few months. So actual conferences. We loved it! Uh, I think the content was amazing, and so we just released today the talks on YouTube. So go check out the OpenAI YouTube channel, and you can find a bunch of, like, pretty cool content. Lastly, all of that was a lot. And so, we’re going to do an AMA, ask me anything, uh, starting today with the presenters, the APM at OpenAI, uh, for the next hour. So please come and ask us any questions that you would like on the developer forum, uh, the OpenAI developer forum. Last, last, last, sorry, I have a bad joke! I have a bad joke! Uh, we talked about “co” quite a bit. You know how Santa has a naughty list, you know, of kids, like, were naughty. Why was structured outputs on the naughty list? I don’t know. Tell me!
(21:55) Olivia Gar:
Santa heard it was a schema. On that note, see you tomorrow for day, day, day 10 of of 12 days. Bye, bye!
