…or what I should have known before I jumped in
I recently received an invite to try out the OpenAI API beta. As always, I jumped straight in and started playing around. By tweaking the examples I was able to produce some interesting and/or entertaining results.
However, after a little while I realised I didn’t really understand what was happening or what the various parameters really did. So I jumped into the docs and read/watched around the subject. This miniseries of posts are a summary of what I’ve learnt 
 Part 1 covers basics of tokens, the model and prompt design.
 Part 2 (this post) covers the logprobs and the “creativity” controls.
 Part 3 covers few shot learning and finetuning.
If you were hoping for examples of what it can do, this isn’t going to be for you. I’d recommend checking out the impressive examples in the documentation.
Controlling “creativity”
In the previous post I introduced the model as a function which returns an output token. Well, I lied. It’s a reasonable starting point but glosses over some of the detail needed to generate more “creative” responses. This creativity comes in everyone’s favourite form, probabilities, or more specifically logprobs
…
I’m making it sound a lot worse than it really is and a basic understanding should be within everyone’s grasp. Personally, I can follow the steps involved intuitively, but would definitely struggle if I was trying to come up with them from first principles. Let’s deal with logprobs
first.
Logprobs
Most people are already familiar with more than one method of specifying probabilities. logprobs
are just another way. For example, 1 in 10
is equivalent to 10%
as a percentage, is equivalent to 0.1
as a decimal fraction, is equivalent to 2.303...
as a logprob
. The following lookup table helped me understand them 
Percentage  logprob 

100  0 
99.99  0.0001 
99.9  0.001 
~99  0.01 
x  log(x/100) 
e(x)*100  x 
The API uses logprobs
because it is computationally easier to calculate the probability of a sequence of tokens if their individual probabilities are expressed as logprobs
(their sum) rather than percentages (their product). The only thing I really hold in my head about logprobs
is that the largest value (remember they’re negative numbers) has the highest probability. So how does the API use them?
Revisiting the model output
Updating the previous example of prompting the model with "Once upon a"
to include the logprob

model(tokenise("Once upon a")) == (tokenise(" time")[0], logprob("96.45%"))
But even this isn’t a true representation of the output, instead it’s my understanding that the model is actually outputting a logprob
for every known token. The API then sorts this from most likely to least and truncates it after N values, producing something more like 
model(tokenise("Once upon a")) == [
(tokenise(" time")[0], logprob("96.45%")),
(tokenise(" Time")[0], logprob("0.67%")),
(tokenise(" midnight")[0], logprob("0.31%")),
# ...
]
Having access to these raw probabilities for each token leads to some interesting possibilities. Instead of always picking the most likely token, what if the API randomly chose from one of the most likely values?
Interestingly, the API also returns the logprobs for tokens in the prompt. That suggests that the loop I referred to when discussing basic prompt design, runs for each token in the prompt as well as those produced for the completion.
Adding randominsation to the output
It turns out that the APIs behaviour is always to randomly choose from the set of output tokens. Prior to sampling, each token is first weighted by its relative probability. To change the model’s behaviour, these probabilities can be manipulated with the following request options, which were until now set to 0
and 1
respectively 
Temperature
 a value between0
and1
. At0
, randomness is removed by boosting the most likely token to100%
. Values greater than0
have the effect of boosting the next most probable tokens. The exact effect a particular value will have is hard to reason about, but the greater the value, the less likely a moreprobable token will be boosted relative to a lessprobable token.Top P
 again a value between0
and1
but this time representing a decimal fraction. The effect of the value is similar toTemperature
but it is easier to reason about the effect a particular value will have. The top N tokens with a cumulative probability greater than the value specified are boosted, with all other tokens suppressed e.g. a value of0
will select only the top token.
In the above descriptions all boosts are relative. The total probability of all tokens can not exceed 100%, therefore a boost in one probability necessitates a suppression of another. It typically doesn’t make sense to set both of these options, as they both attempt to manipulate the same probabilities in similar ways. So the documentation advice is to set whichever you’re not using to 1
.
Looping the loop
Understanding that the model is no longer restricted to just picking the most likely next token, changed my mental model of the generation process, from a linear sequence of tokens being generated, to a somewhat controlled random walk through a tree of possible sequences. The original linear sequence being just one possible path, where the highest probability branch was chosen on each iteration, but which does not necessarily have the highest cumulative probability when the full path is considered.
The API provides a convenience option Best of
to allow you to run N completions and return only the completion with the highest cumulative probability (this is one reason for logprobs
). With the right degree of randomness, this should mean the API is able to find a completion with a higher cumulative probability than simply choosing the highest probability token on each iteration.
I say this is a convenience because as opposed to the options above which run within the loop, this loop wraps that loop. So whilst it might save some bandwidth, it costs the same as invoking the API N times (using the n
option) and performing the small amount of postprocessing yourself.
Probability penalties
When using no or low degrees of randomness, I’ve found it very easy to end up with repetitive completions. To help with this, as well as transforming the probabilities in isolation, it is also possible to transform them as a function of the input tokens.
The following two request options are available, in both cases they are a value between 0
and 1
representing the maximum suppression to apply to a token’s probability as a decimal fraction 
Presence penalty
 suppress a token’s probability by this amount if it is found in the input.Frequency penalty
 suppress a token’s probability by this amount multiplied by its frequency of occurrence in the input.
These penalties can be freely combined to gently nudge the model away from repeating itself with a presence penalty. Before steadily ratcheting that up to a firm prod, if it continues to repeat itself, with a frequency penalty. 0
values have no effect on the model.
Conclusion
One of the standout things to me which is obvious in retrospect but definitely wasn’t when I first interacted with the models, is that they are pure functions. I think it’s easy to assume with all of the talk of probabilities, along with the lack of anyone really understanding what the models are doing internally, that they are in some way nondeterministic in their “thinking”. Knowing that they are in fact deterministic somehow puts my mind at ease.
But then I get carried away thinking philosophically  what really is creativity? Luckily for you, I dodge this question and others in part 3.