refactors readme

Author: ted-at-openai

README.md

@@ -0,0 +1,63 @@
+# Code editing example
+
+OpenAI's [edits](https://openai.com/blog/gpt-3-edit-insert/) endpoint is particularly useful for editing code.
+
+Unlike completions, edits takes two inputs: the text to edit and an instruction.
+
+For example, if you wanted to edit a Python function, you could supply the text of the function and an instruction like "add a docstring".
+
+Example text input to `code-davinci-edit-001`:
+
+```python
+def tribonacci(n):
+    if n == 0:
+        return 0
+    elif n == 1:
+        return 1
+    elif n == 2:
+        return 1
+    elif n == 3:
+        return 2
+    else:
+        return tribonacci(n-1) + tribonacci(n-2) + tribonacci(n-3)
+```
+
+Example instruction inputs:
+
+```text
+add a docstring
+```
+
+```text
+Add typing, using Python 3.9 conventions
+```
+
+```text
+improved the runtime
+```
+
+```text
+Add a test.
+```
+
+```text
+Translate to JavaScript (or Rust or Lisp or any language you like)
+```
+
+Example output after improving the runtime and translating to JavaScript:
+
+```JavaScript
+function tribonacci(n) {
+  let a = 0;
+  let b = 1;
+  let c = 1;
+  for (let i = 0; i < n; i++) {
+    [a, b, c] = [b, c, a + b + c];
+  }
+  return a;
+}
+```
+
+As you can see, `code-davinci-edit-001` was able to successfully reduce the function's runtime from exponential down to linear, as well as convert from Python to JavaScript.
+
+Experiment with code editing using `code-davinci-edit-001` in the [OpenAI Playground](https://beta.openai.com/playground?mode=edit&model=code-davinci-edit-001).

code_editing_examples.md

@@ -0,0 +1,41 @@
+# Code explanation examples
+
+GPT's understanding of code can be applied to many use cases, e.g.:
+
+* Generating in-code documentation (e.g., Python docstrings, git commit messages)
+* Generating out-of-code documentation (e.g., man pages)
+* An interactive code exploration tool
+* Communicating program results back to users via a natural language interface
+
+For example, if you wanted to understand a SQL query, you could give `code-davinci-002` the following example prompt:
+
+````text
+A SQL query:
+```
+SELECT c.customer_id
+FROM Customers c
+JOIN Streaming s
+ON c.customer_id = s.customer_id
+WHERE c.signup_date BETWEEN '2020-03-01' AND '2020-03-31'
+AND s.watch_date BETWEEN c.signup_date AND DATE_ADD(c.signup_date, INTERVAL 30 DAY)
+GROUP BY c.customer_id
+HAVING SUM(s.watch_minutes) > 50 * 60
+```
+
+Questions:
+1. What does the SQL query do?
+2. Why might someone be interested in this time period?
+3. Why might a company be interested in this SQL query?
+
+Answers:
+````
+
+[Output]((https://beta.openai.com/playground/p/Sv1VQKbJV1TZKmiTK9r6nlj3)):
+
+```text
+1. The SQL query finds all customers who signed up in March 2020 and watched more than 50 hours of content in the first 30 days after signing up.
+2. The time period is interesting because it is the first month of the COVID-19 pandemic.
+3. A company might be interested in this SQL query because it can help them understand how the pandemic has affected their business.
+```
+
+Note that `code-davinci-002` is not trained to follow instructions and therefore usually needs examples or other structure to help steer its output, as well as stop sequences to stop generating. For easier prompting, try `text-davinci-003`.

code_explanation_examples.md

@@ -0,0 +1,31 @@
+# Code writing examples
+
+GPT-3 is able to write code as well as text.
+
+Here's an example of `code-davinci-002` writing a SQL query:
+
+````text
+SQL tables (and columns):
+* Customers(customer_id, signup_date)
+* Streaming(customer_id, video_id, watch_date, watch_minutes)
+
+A well-written SQL query that lists customers who signed up during March 2020 and watched more than 50 hours of video in their first 30 days:
+```
+````
+
+[Output](https://beta.openai.com/playground/p/r2mw99cANoa0TJHok725CeaC):
+
+```sql
+SELECT c.customer_id
+FROM Customers c
+JOIN Streaming s
+ON c.customer_id = s.customer_id
+WHERE c.signup_date BETWEEN '2020-03-01' AND '2020-03-31'
+AND s.watch_date BETWEEN c.signup_date AND DATE_ADD(c.signup_date, INTERVAL 30 DAY)
+GROUP BY c.customer_id
+HAVING SUM(s.watch_minutes) > 50 * 60
+```
+
+Helpfully, `code-davinci-002` is able to make inferences from variable names; for example, it infers that `watch_minutes` has units of minutes and therefore needs to be converted by a factor of 60 before being compared with 50 hours.
+
+For easier prompting, you can also try `text-davinci-003`.

code_writing_examples.md

@@ -0,0 +1,152 @@
+# How to work with large language models
+
+## How large language models work
+
+[Large language models][Large language models Blog Post] are functions that map text to text. Given an input string of text, a large language model predicts the text that should come next.
+
+The magic of large language models is that by being trained to minimize this prediction error over vast quantities of text, the models end up learning concepts useful for these predictions. For example, they learn:
+
+* how to spell
+* how grammar works
+* how to paraphrase
+* how to answer questions
+* how to hold a conversation
+* how to write in many languages
+* how to code
+* etc.
+
+None of these capabilities are explicitly programmed in—they all emerge as a result of training.
+
+GPT-3 powers [hundreds of software products][GPT3 Apps Blog Post], including productivity apps, education apps, games, and more.
+
+## How to control a large language model
+
+Of all the inputs to a large language model, by far the most influential is the text prompt.
+
+Large language models can be prompted to produce output in a few ways:
+
+* **Instruction**: Tell the model what you want
+* **Completion**: Induce the model to complete the beginning of what you want
+* **Demonstration**: Show the model what you want, with either:
+  * A few examples in the prompt
+  * Many hundreds or thousands of examples in a fine-tuning training dataset
+
+An example of each is shown below.
+
+### Instruction prompts
+
+Instruction-following models (e.g., `text-davinci-003` or any model beginning with `text-`) are specially designed to follow instructions. Write your instruction at the top of the prompt (or at the bottom, or both), and the model will do its best to follow the instruction and then stop. Instructions can be detailed, so don't be afraid to write a paragraph explicitly detailing the output you want.
+
+Example instruction prompt:
+
+```text
+Extract the name of the author from the quotation below.
+
+“Some humans theorize that intelligent species go extinct before they can expand into outer space. If they're correct, then the hush of the night sky is the silence of the graveyard.”
+― Ted Chiang, Exhalation
+```
+
+Output:
+
+```text
+Ted Chiang
+```
+
+### Completion prompt example
+
+Completion-style prompts take advantage of how large language models try to write text they think is mostly likely to come next. To steer the model, try beginning a pattern or sentence that will be completed by the output you want to see. Relative to direct instructions, this mode of steering large language models can take more care and experimentation. In addition, the models won't necessarily know where to stop, so you will often need stop sequences or post-processing to cut off text generated beyond the desired output.
+
+Example completion prompt:
+
+```text
+“Some humans theorize that intelligent species go extinct before they can expand into outer space. If they're correct, then the hush of the night sky is the silence of the graveyard.”
+― Ted Chiang, Exhalation
+
+The author of this quote is
+```
+
+Output:
+
+```text
+ Ted Chiang
+```
+
+### Demonstration prompt example (few-shot learning)
+
+Similar to completion-style prompts, demonstrations can show the model what you want it to do. This approach is sometimes called few-shot learning, as the model learns from a few examples provided in the prompt.
+
+Example demonstration prompt:
+
+```text
+Quote:
+“When the reasoning mind is forced to confront the impossible again and again, it has no choice but to adapt.”
+― N.K. Jemisin, The Fifth Season
+Author: N.K. Jemisin
+
+Quote:
+“Some humans theorize that intelligent species go extinct before they can expand into outer space. If they're correct, then the hush of the night sky is the silence of the graveyard.”
+― Ted Chiang, Exhalation
+Author:
+```
+
+Output:
+
+```text
+ Ted Chiang
+```
+
+### Fine-tuned prompt example
+
+With enough training examples, you can [fine-tune][Fine Tuning Docs] a custom model. In this case, instructions become unnecessary, as the model can learn the task from the training data provided. However, it can be helpful to include separator sequences (e.g., `->` or `###` or any string that doesn't commonly appear in your inputs) to tell the model when the prompt has ended and the output should begin. Without separator sequences, there is a risk that the model continues elaborating on the input text rather than starting on the answer you want to see.
+
+Example fine-tuned prompt (for a model that has been custom trained on similar prompt-completion pairs):
+
+```text
+“Some humans theorize that intelligent species go extinct before they can expand into outer space. If they're correct, then the hush of the night sky is the silence of the graveyard.”
+― Ted Chiang, Exhalation
+
+###
+
+
+```
+
+Output:
+
+```text
+ Ted Chiang
+```
+
+## Code Capabilities
+
+Large language models aren't only great at text - they can be great at code too. OpenAI's specialized code model is called [Codex].
+
+Codex powers [more than 70 products][Codex Apps Blog Post], including:
+
+* [GitHub Copilot] (autocompletes code in VS Code and other IDEs)
+* [Pygma](https://pygma.app/) (turns Figma designs into code)
+* [Replit](https://replit.com/) (has an 'Explain code' button and other features)
+* [Warp](https://www.warp.dev/) (a smart terminal with AI command search)
+* [Machinet](https://machinet.net/) (writes Java unit test templates)
+
+Note that unlike instruction-following text models (e.g., `text-davinci-002`), Codex is *not* trained to follow instructions. As a result, designing good prompts can take more care.
+
+### More prompt advice
+
+For more prompt examples, visit [OpenAI Examples][OpenAI Examples].
+
+In general, the input prompt is the best lever for improving model outputs. You can try tricks like:
+
+* **Give more explicit instructions.** E.g., if you want the output to be a comma separated list, ask it to return a comma separated list. If you want it to say "I don't know" when the it doesn't know the answer, tell it 'Say "I don't know" if you do not know the answer.'
+* **Supply better examples.** If you're demonstrating examples in your prompt, make sure that your examples are diverse and high quality.
+* **Ask the model to answer as if it was an expert.** Explicitly asking the model to produce high quality output or output as if it was written by an expert can induce the model to give higher quality answers that it thinks an expert would write. E.g., "The following answer is correct, high-quality, and written by an expert."
+* **Prompt the model to write down the series of steps explaining its reasoning.** E.g., prepend your answer with something like "[Let's think step by step](https://arxiv.org/pdf/2205.11916v1.pdf)." Prompting the model to give an explanation of its reasoning before its final answer can increase the likelihood that its final answer is consistent and correct.
+
+
+
+[Fine Tuning Docs]: https://beta.openai.com/docs/guides/fine-tuning
+[Codex Apps Blog Post]: https://openai.com/blog/codex-apps/
+[Large language models Blog Post]: https://openai.com/blog/better-language-models/
+[GitHub Copilot]: https://copilot.github.com/
+[Codex]: https://openai.com/blog/openai-codex/
+[GPT3 Apps Blog Post]: https://openai.com/blog/gpt-3-apps/
+[OpenAI Examples]: https://beta.openai.com/examples

how_to_work_with_large_language_models.md

@@ -0,0 +1,49 @@
+# Text comparison examples
+
+The [OpenAI API embeddings endpoint](https://beta.openai.com/docs/guides/embeddings) can be used to measure relatedness or similarity between pieces of text.
+
+By leveraging GPT-3's understanding of text, these embeddings [achieved state-of-the-art results](https://arxiv.org/abs/2201.10005) on benchmarks in unsupervised learning and transfer learning settings.
+
+Embeddings can be used for semantic search, recommendations, cluster analysis, near-duplicate detection, and more.
+
+For more information, read OpenAI's blog post announcements:
+
+* [Introducing Text and Code Embeddings (Jan 2022)](https://openai.com/blog/introducing-text-and-code-embeddings/)
+* [New and Improved Embedding Model (Dec 2022)](https://openai.com/blog/new-and-improved-embedding-model/)
+
+## Semantic search
+
+Embeddings can be used for search either by themselves or as a feature in a larger system.
+
+The simplest way to use embeddings for search is as follows:
+
+* Before the search (precompute):
+  * Split your text corpus into chunks smaller than the token limit (8,191 tokens for `text-embedding-ada-002`)
+  * Embed each chunk of text
+  * Store those embeddings in your own database or in a vector search provider like [Pinecone](https://www.pinecone.io) or [Weaviate](https://weaviate.io)
+* At the time of the search (live compute):
+  * Embed the search query
+  * Find the closest embeddings in your database
+  * Return the top results
+
+An example of how to use embeddings for search is shown in [Semantic_text_search_using_embeddings.ipynb](examples/Semantic_text_search_using_embeddings.ipynb).
+
+In more advanced search systems, the the cosine similarity of embeddings can be used as one feature among many in ranking search results.
+
+## Question answering
+
+The best way to get reliably honest answers from GPT-3 is to give it source documents in which it can locate correct answers. Using the semantic search procedure above, you can cheaply search a corpus of documents for relevant information and then give that information to GPT-3, via the prompt, to answer a question. We demonstrate in [Question_answering_using_embeddings.ipynb](examples/Question_answering_using_embeddings.ipynb).
+
+## Recommendations
+
+Recommendations are quite similar to search, except that instead of a free-form text query, the inputs are items in a set.
+
+An example of how to use embeddings for recommendations is shown in [Recommendation_using_embeddings.ipynb](examples/Recommendation_using_embeddings.ipynb).
+
+Similar to search, these cosine similarity scores can either be used on their own to rank items or as features in larger ranking algorithms.
+
+## Customizing Embeddings
+
+Although OpenAI's embedding model weights cannot be fine-tuned, you can nevertheless use training data to customize embeddings to your application.
+
+In [Customizing_embeddings.ipynb](examples/Customizing_embeddings.ipynb), we provide an example method for customizing your embeddings using training data. The idea of the method is to train a custom matrix to multiply embedding vectors by in order to get new customized embeddings. With good training data, this custom matrix will help emphasize the features relevant to your training labels. You can equivalently consider the matrix multiplication as (a) a modification of the embeddings or (b) a modification of the distance function used to measure the distances between embeddings.