diff --git a/README.md b/README.md index 5d16fd988..382d28c6e 100644 --- a/README.md +++ b/README.md @@ -65,7 +65,7 @@ PostgresML is a machine learning extension for PostgreSQL that enables you to pe *SQL query* -```sql +```postgresql SELECT pgml.transform( 'translation_en_to_fr', inputs => ARRAY[ @@ -76,7 +76,7 @@ SELECT pgml.transform( ``` *Result* -```sql +```postgresql french ------------------------------------------------------------ @@ -89,7 +89,7 @@ SELECT pgml.transform( **Sentiment Analysis** *SQL query* -```sql +```postgresql SELECT pgml.transform( task => 'text-classification', inputs => ARRAY[ @@ -99,7 +99,7 @@ SELECT pgml.transform( ) AS positivity; ``` *Result* -```sql +```postgresql positivity ------------------------------------------------------ [ @@ -117,7 +117,7 @@ SELECT pgml.transform( **Training a classification model** *Training* -```sql +```postgresql SELECT * FROM pgml.train( 'Handwritten Digit Image Classifier', algorithm => 'xgboost', @@ -128,7 +128,7 @@ SELECT * FROM pgml.train( ``` *Inference* -```sql +```postgresql SELECT pgml.predict( 'My Classification Project', ARRAY[0.1, 2.0, 5.0] @@ -203,7 +203,7 @@ PostgresML integrates 🤗 Hugging Face Transformers to bring state-of-the-art N You can call different NLP tasks and customize using them using the following SQL query. -```sql +```postgresql SELECT pgml.transform( task => TEXT OR JSONB, -- Pipeline initializer arguments inputs => TEXT[] OR BYTEA[], -- inputs for inference @@ -220,7 +220,7 @@ Text classification involves assigning a label or category to a given text. Comm Sentiment analysis is a type of natural language processing technique that involves analyzing a piece of text to determine the sentiment or emotion expressed within it. It can be used to classify a text as positive, negative, or neutral, and has a wide range of applications in fields such as marketing, customer service, and political analysis. *Basic usage* -```sql +```postgresql SELECT pgml.transform( task => 'text-classification', inputs => ARRAY[ @@ -242,7 +242,7 @@ The default model trained on around 40,000 English tweets and that has POS (positive), NEG (negative), and NEU (neutral) labels for its classes, include this information in the JSONB object when making your query. -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I love how amazingly simple ML has become!', @@ -265,7 +265,7 @@ SELECT pgml.transform( By selecting a model that has been specifically designed for a particular industry, you can achieve more accurate and relevant text classification. An example of such a model is FinBERT, a pre-trained NLP model that has been optimized for analyzing sentiment in financial text. FinBERT was created by training the BERT language model on a large financial corpus, and fine-tuning it to specifically classify financial sentiment. When using FinBERT, the model will provide softmax outputs for three different labels: positive, negative, or neutral. -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'Stocks rallied and the British pound gained.', @@ -295,7 +295,7 @@ The GLUE dataset is the benchmark dataset for evaluating NLI models. There are d If you want to use an NLI model, you can find them on the :hugs: Hugging Face model hub. Look for models with "mnli". -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'A soccer game with multiple males playing. Some men are playing a sport.' @@ -316,7 +316,7 @@ The QNLI task involves determining whether a given question can be answered by t If you want to use an QNLI model, you can find them on the :hugs: Hugging Face model hub. Look for models with "qnli". -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'Where is the capital of France?, Paris is the capital of France.' @@ -339,7 +339,7 @@ The Quora Question Pairs model is designed to evaluate whether two given questio If you want to use an QQP model, you can find them on the :hugs: Hugging Face model hub. Look for models with `qqp`. -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'Which city is the capital of France?, Where is the capital of France?' @@ -362,7 +362,7 @@ Linguistic Acceptability is a task that involves evaluating the grammatical corr If you want to use a grammatical correctness model, you can find them on the :hugs: Hugging Face model hub. Look for models with `cola`. -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I will walk to home when I went through the bus.' @@ -388,7 +388,7 @@ In the example provided below, we will demonstrate how to classify a given sente Look for models with `mnli` to use a zero-shot classification model on the :hugs: Hugging Face model hub. -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I have a problem with my iphone that needs to be resolved asap!!' @@ -421,7 +421,7 @@ Token classification is a task in natural language understanding, where labels a ### Named Entity Recognition Named Entity Recognition (NER) is a task that involves identifying named entities in a text. These entities can include the names of people, locations, or organizations. The task is completed by labeling each token with a class for each named entity and a class named "0" for tokens that don't contain any entities. In this task, the input is text, and the output is the annotated text with named entities. -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I am Omar and I live in New York City.' @@ -443,7 +443,7 @@ SELECT pgml.transform( PoS tagging is a task that involves identifying the parts of speech, such as nouns, pronouns, adjectives, or verbs, in a given text. In this task, the model labels each word with a specific part of speech. Look for models with `pos` to use a zero-shot classification model on the :hugs: Hugging Face model hub. -```sql +```postgresql select pgml.transform( inputs => array [ 'I live in Amsterdam.' @@ -470,7 +470,7 @@ Translation is the task of converting text written in one language into another You have the option to select from over 2000 models available on the Hugging Face hub for translation. -```sql +```postgresql select pgml.transform( inputs => array[ 'How are you?' @@ -491,7 +491,7 @@ Summarization involves creating a condensed version of a document that includes ![summarization](pgml-cms/docs/images/summarization.png) -```sql +```postgresql select pgml.transform( task => '{"task": "summarization", "model": "sshleifer/distilbart-cnn-12-6" @@ -509,7 +509,7 @@ select pgml.transform( ``` You can control the length of summary_text by passing `min_length` and `max_length` as arguments to the SQL query. -```sql +```postgresql select pgml.transform( task => '{"task": "summarization", "model": "sshleifer/distilbart-cnn-12-6" @@ -535,7 +535,7 @@ Question Answering models are designed to retrieve the answer to a question from ![question answering](pgml-cms/docs/images/question-answering.png) -```sql +```postgresql SELECT pgml.transform( 'question-answering', inputs => ARRAY[ @@ -564,7 +564,7 @@ Text generation is the task of producing new text, such as filling in incomplete ![text generation](pgml-cms/docs/images/text-generation.png) -```sql +```postgresql SELECT pgml.transform( task => 'text-generation', inputs => ARRAY[ @@ -584,7 +584,7 @@ SELECT pgml.transform( To use a specific model from :hugs: model hub, pass the model name along with task name in task. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -603,7 +603,7 @@ SELECT pgml.transform( ``` To make the generated text longer, you can include the argument `max_length` and specify the desired maximum length of the text. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -625,7 +625,7 @@ SELECT pgml.transform( ``` If you want the model to generate more than one output, you can specify the number of desired output sequences by including the argument `num_return_sequences` in the arguments. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -651,7 +651,7 @@ SELECT pgml.transform( ``` Text generation typically utilizes a greedy search algorithm that selects the word with the highest probability as the next word in the sequence. However, an alternative method called beam search can be used, which aims to minimize the possibility of overlooking hidden high probability word combinations. Beam search achieves this by retaining the num_beams most likely hypotheses at each step and ultimately selecting the hypothesis with the highest overall probability. We set `num_beams > 1` and `early_stopping=True` so that generation is finished when all beam hypotheses reached the EOS token. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -681,7 +681,7 @@ However, the randomness of the sampling method can also result in less coherent You can pass `do_sample = True` in the arguments to use sampling methods. It is recommended to alter `temperature` or `top_p` but not both. *Temperature* -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -702,7 +702,7 @@ SELECT pgml.transform( ``` *Top p* -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -726,7 +726,7 @@ Text-to-text generation methods, such as T5, are neural network architectures de ![text-to-text](pgml-cms/docs/images/text-to-text-generation.png) *Translation* -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text2text-generation" @@ -745,7 +745,7 @@ SELECT pgml.transform( ``` Similar to other tasks, we can specify a model for text-to-text generation. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text2text-generation", @@ -762,7 +762,7 @@ SELECT pgml.transform( Fill-mask refers to a task where certain words in a sentence are hidden or "masked", and the objective is to predict what words should fill in those masked positions. Such models are valuable when we want to gain statistical insights about the language used to train the model. ![fill mask](pgml-cms/docs/images/fill-mask.png) -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "fill-mask" @@ -794,7 +794,7 @@ Using a vector database involves three key steps: creating embeddings, indexing To create embeddings for your data, you first need to choose a transformer that can generate embeddings from your input data. Some popular transformer options include BERT, GPT-2, and T5. Once you've selected a transformer, you can use it to generate embeddings for your data. In the following section, we will demonstrate how to use PostgresML to generate embeddings for a dataset of tweets commonly used in sentiment analysis. To generate the embeddings, we will use the `pgml.embed` function, which will generate an embedding for each tweet in the dataset. These embeddings will then be inserted into a table called tweet_embeddings. -```sql +```postgresql SELECT pgml.load_dataset('tweet_eval', 'sentiment'); SELECT * @@ -831,13 +831,13 @@ The index is being created on the embedding column in the tweet_embeddings table By creating an index on the embedding column, the database can quickly search for and retrieve records that are similar to a given query vector. This can be useful for a variety of machine learning applications, such as similarity search or recommendation systems. -```sql +```postgresql CREATE INDEX ON tweet_embeddings USING ivfflat (embedding vector_cosine_ops); ``` ## Step 3: Querying the index using embeddings for your queries Once your embeddings have been indexed, you can use them to perform queries against your database. To do this, you'll need to provide a query embedding that represents the query you want to perform. The index will then return the closest matching embeddings from your database, based on the similarity between the query embedding and the stored embeddings. -```sql +```postgresql WITH query AS ( SELECT pgml.embed('distilbert-base-uncased', 'Star Wars christmas special is on Disney')::vector AS embedding ) @@ -876,7 +876,7 @@ In this section, we will provide a step-by-step walkthrough for fine-tuning a La ### 1. Loading the Dataset To begin, create a table to store your dataset. In this example, we use the 'imdb' dataset from Hugging Face. IMDB dataset contains three splits: train (25K rows), test (25K rows) and unsupervised (50K rows). In train and test splits, negative class has label 0 and positive class label 1. All rows in unsupervised split has a label of -1. -```sql +```postgresql SELECT pgml.load_dataset('imdb'); ``` @@ -888,7 +888,7 @@ We will create a view of the dataset by performing the following operations: - Shuffled view of the dataset to ensure randomness in the distribution of data. - Remove all the unsupervised splits that have label = -1. -```sql +```postgresql CREATE VIEW pgml.imdb_shuffled_view AS SELECT label, @@ -910,7 +910,7 @@ Before splitting the data into training and test sets, it's essential to perform To analyze the distribution of labels in the shuffled dataset, you can use the following SQL query: -```sql +```postgresql -- Count the occurrences of each label in the shuffled dataset pgml=# SELECT class, @@ -931,7 +931,7 @@ This query provides insights into the distribution of labels, helping you unders #### 3.2 Sample Records To get a glimpse of the data, you can retrieve a sample of records from the shuffled dataset: -```sql +```postgresql -- Retrieve a sample of records from the shuffled dataset pgml=# SELECT LEFT(text,100) AS text, class FROM pgml.imdb_shuffled_view @@ -957,7 +957,7 @@ Feel free to explore other aspects of the data, such as the distribution of text Create views for training and test data by splitting the shuffled dataset. In this example, 80% is allocated for training, and 20% for testing. We will use `pgml.imdb_test_view` in [section 6](#6-inference-using-fine-tuned-model) for batch predictions using the finetuned model. -```sql +```postgresql -- Create a view for training data CREATE VIEW pgml.imdb_train_view AS SELECT * @@ -975,7 +975,7 @@ OFFSET (SELECT COUNT(*) * 0.8 FROM pgml.imdb_shuffled_view); Now, fine-tune the Language Model for text classification using the created training view. In the following sections, you will see a detailed explanation of different parameters used during fine-tuning. Fine-tuned model is pushed to your public Hugging Face Hub periodically. A new repository will be created under your username using your project name (`imdb_review_sentiment` in this case). You can also choose to push the model to a private repository by setting `hub_private_repo: true` in training arguments. -```sql +```postgresql SELECT pgml.tune( 'imdb_review_sentiment', task => 'text-classification', @@ -1122,7 +1122,7 @@ Now, that we have fine-tuned model on Hugging Face Hub, we can use [`pgml.transf **Real-time predictions** Here is an example pgml.transform call for real-time predictions on the newly minted LLM fine-tuned on IMDB review dataset. -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-classification", @@ -1143,7 +1143,7 @@ Time: 175.264 ms **Batch predictions** -```sql +```postgresql pgml=# SELECT LEFT(text, 100) AS truncated_text, class, @@ -1179,14 +1179,14 @@ Sometimes, it's necessary to restart the training process from a previously trai Specify the name of the existing model you want to use as a starting point. This is achieved by setting the `model_name` parameter in the `pgml.tune` function. In the example below, it is set to 'santiadavani/imdb_review_sentiement'. -```sql +```postgresql model_name => 'santiadavani/imdb_review_sentiement', ``` ### Adjust Hyperparameters Fine-tune hyperparameters as needed for the restarted training process. This might include modifying learning rates, batch sizes, or training epochs. In the example below, hyperparameters such as learning rate, batch sizes, and epochs are adjusted. -```sql +```postgresql "training_args": { "learning_rate": 2e-5, "per_device_train_batch_size": 16, @@ -1201,7 +1201,7 @@ Fine-tune hyperparameters as needed for the restarted training process. This mig ### Ensure Consistent Dataset Configuration Confirm that the dataset configuration remains consistent, including specifying the same text and class columns as in the previous training. This ensures compatibility between the existing model and the restarted training process. -```sql +```postgresql "dataset_args": { "text_column": "text", "class_column": "class" @@ -1211,7 +1211,7 @@ Confirm that the dataset configuration remains consistent, including specifying ### Run the pgml.tune Function Execute the `pgml.tune` function with the updated parameters to initiate the training restart. The function will leverage the existing model and adapt it based on the adjusted hyperparameters and dataset configuration. -```sql +```postgresql SELECT pgml.tune( 'imdb_review_sentiement', task => 'text-classification', @@ -1250,7 +1250,7 @@ However, in certain scenarios, pushing the model to a central repository and pul ### 1. Load and Shuffle the Dataset In this section, we begin by loading the FinGPT sentiment analysis dataset using the `pgml.load_dataset` function. The dataset is then processed and organized into a shuffled view (pgml.fingpt_sentiment_shuffled_view), ensuring a randomized order of records. This step is crucial for preventing biases introduced by the original data ordering and enhancing the training process. -```sql +```postgresql -- Load the dataset SELECT pgml.load_dataset('FinGPT/fingpt-sentiment-train'); @@ -1262,7 +1262,7 @@ SELECT * FROM pgml."FinGPT/fingpt-sentiment-train" ORDER BY RANDOM(); ### 2. Explore Class Distribution Once the dataset is loaded and shuffled, we delve into understanding the distribution of sentiment classes within the data. By querying the shuffled view, we obtain valuable insights into the number of instances for each sentiment class. This exploration is essential for gaining a comprehensive understanding of the dataset and its inherent class imbalances. -```sql +```postgresql -- Explore class distribution SELECTpgml=# SELECT output, @@ -1288,7 +1288,7 @@ ORDER BY output; ### 3. Create Training and Test Views To facilitate the training process, we create distinct views for training and testing purposes. The training view (pgml.fingpt_sentiment_train_view) contains 80% of the shuffled dataset, enabling the model to learn patterns and associations. Simultaneously, the test view (pgml.fingpt_sentiment_test_view) encompasses the remaining 20% of the data, providing a reliable evaluation set to assess the model's performance. -```sql +```postgresql -- Create a view for training data (e.g., 80% of the shuffled records) CREATE VIEW pgml.fingpt_sentiment_train_view AS SELECT * @@ -1306,7 +1306,7 @@ OFFSET (SELECT COUNT(*) * 0.8 FROM pgml.fingpt_sentiment_shuffled_view); ### 4. Fine-Tune the Model for 9 Classes In the final section, we kick off the fine-tuning process using the `pgml.tune` function. The model will be internally configured for sentiment analysis with 9 classes. The training is executed on the 80% of the train view and evaluated on the remaining 20% of the train view. The test view is reserved for evaluating the model's accuracy after training is completed. Please note that the option `hub_private_repo: true` is used to push the model to a private Hugging Face repository. -```sql +```postgresql -- Fine-tune the model for 9 classes without HUB token SELECT pgml.tune( 'fingpt_sentiement', @@ -1387,7 +1387,7 @@ What makes the conversation task truly remarkable is its remarkable versatility. ### Fine-tuning Llama2-7b model using LoRA In this section, we will explore how to fine-tune the Llama2-7b-chat large language model for the financial sentiment data discussed in the previous [section](#text-classification-9-classes) utilizing the pgml.tune function and employing the LoRA approach. LoRA is a technique that enables efficient fine-tuning of large language models by only updating a small subset of the model's weights during fine-tuning, while keeping the majority of the weights frozen. This approach can significantly reduce the computational requirements and memory footprint compared to traditional full model fine-tuning. -```sql +```postgresql SELECT pgml.tune( 'fingpt-llama2-7b-chat', task => 'conversation', diff --git a/pgml-cms/blog/announcing-gptq-and-ggml-quantized-llm-support-for-huggingface-transformers.md b/pgml-cms/blog/announcing-gptq-and-ggml-quantized-llm-support-for-huggingface-transformers.md index 6242776db..70f0202e0 100644 --- a/pgml-cms/blog/announcing-gptq-and-ggml-quantized-llm-support-for-huggingface-transformers.md +++ b/pgml-cms/blog/announcing-gptq-and-ggml-quantized-llm-support-for-huggingface-transformers.md @@ -41,7 +41,7 @@ You can select the data type for torch tensors in PostgresML by setting the `tor !!! code\_block time="4584.906 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "model": "tiiuae/falcon-7b-instruct", @@ -102,7 +102,7 @@ PostgresML will automatically use GPTQ or GGML when a HuggingFace model has one !!! code\_block time="281.213 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -136,7 +136,7 @@ SELECT pgml.transform( !!! code\_block time="252.213 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -167,7 +167,7 @@ SELECT pgml.transform( !!! code\_block time="279.888 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -204,7 +204,7 @@ We can specify the CPU by passing a `"device": "cpu"` argument to the `task`. !!! code\_block time="266.997 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -236,7 +236,7 @@ SELECT pgml.transform( !!! code\_block time="33224.136 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -274,7 +274,7 @@ HuggingFace and these libraries have a lot of great models. Not all of these mod !!! code\_block time="3411.324 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -306,7 +306,7 @@ SELECT pgml.transform( !!! code\_block time="4198.817 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -338,7 +338,7 @@ SELECT pgml.transform( !!! code\_block time="4198.817 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -372,7 +372,7 @@ Many of these models are published with multiple different quantization methods !!! code\_block time="6498.597" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -410,7 +410,7 @@ Shoutout to [Tostino](https://github.com/Tostino/) for the extended example belo !!! code\_block time="3784.565" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", diff --git a/pgml-cms/blog/generating-llm-embeddings-with-open-source-models-in-postgresml.md b/pgml-cms/blog/generating-llm-embeddings-with-open-source-models-in-postgresml.md index 317a0d346..b66129614 100644 --- a/pgml-cms/blog/generating-llm-embeddings-with-open-source-models-in-postgresml.md +++ b/pgml-cms/blog/generating-llm-embeddings-with-open-source-models-in-postgresml.md @@ -142,7 +142,7 @@ Aside from using this function with strings passed from a client, we can use it !!! generic -!!! code\_block time="54.820 ms" +!!! code_block time="54.820 ms" ```postgresql SELECT @@ -156,7 +156,7 @@ LIMIT 1; !!! results -``` +```postgressql CREATE INDEX ``` diff --git a/pgml-cms/blog/how-to-improve-search-results-with-machine-learning.md b/pgml-cms/blog/how-to-improve-search-results-with-machine-learning.md index 5ee950918..074d431ea 100644 --- a/pgml-cms/blog/how-to-improve-search-results-with-machine-learning.md +++ b/pgml-cms/blog/how-to-improve-search-results-with-machine-learning.md @@ -36,7 +36,7 @@ Our search application will start with a **documents** table. Our documents have !!! code\_block time="10.493 ms" -```sql +```postgresql CREATE TABLE documents ( id BIGSERIAL PRIMARY KEY, title TEXT, @@ -54,7 +54,7 @@ We can add new documents to our _text corpus_ with the standard SQL `INSERT` sta !!! code\_block time="3.417 ms" -```sql +```postgresql INSERT INTO documents (title, body) VALUES ('This is a title', 'This is the body of the first document.'), ('This is another title', 'This is the body of the second document.'), @@ -79,7 +79,7 @@ You can configure the grammatical rules in many advanced ways, but we'll use the !!! code\_block time="0.651 ms" -```sql +```postgresql SELECT * FROM documents WHERE to_tsvector('english', body) @@ to_tsquery('english', 'second'); @@ -109,7 +109,7 @@ The first step is to store the `tsvector` in the table, so we don't have to gene !!! code\_block time="17.883 ms" -```sql +```postgresql ALTER TABLE documents ADD COLUMN title_and_body_text tsvector GENERATED ALWAYS AS (to_tsvector('english', title || ' ' || body )) STORED; @@ -125,7 +125,7 @@ One nice aspect of generated columns is that they will backfill the data for exi !!! code\_block time="5.145 ms" -```sql +```postgresql CREATE INDEX documents_title_and_body_text_index ON documents USING GIN (title_and_body_text); @@ -141,7 +141,7 @@ And now, we'll demonstrate a slightly more complex `tsquery`, that requires both !!! code\_block time="3.673 ms" -```sql +```postgresql SELECT * FROM documents WHERE title_and_body_text @@ to_tsquery('english', 'another & second'); @@ -171,7 +171,7 @@ With multiple query terms OR `|` together, the `ts_rank` will add the numerators !!! code\_block time="0.561 ms" -```sql +```postgresql SELECT ts_rank(title_and_body_text, to_tsquery('english', 'second | title')), * FROM documents ORDER BY ts_rank DESC; @@ -201,7 +201,7 @@ A quick improvement we could make to our search query would be to differentiate !!! code\_block time="0.561 ms" -```sql +```postgresql SELECT ts_rank(title, to_tsquery('english', 'second | title')) AS title_rank, ts_rank(body, to_tsquery('english', 'second | title')) AS body_rank, @@ -230,7 +230,7 @@ First things first, we need to record some user clicks on our search results. We !!! code\_block time="0.561 ms" -```sql +```postgresql CREATE TABLE search_result_clicks ( title_rank REAL, body_rank REAL, @@ -250,7 +250,7 @@ I've made up 4 example searches, across our 3 documents, and recorded the `ts_ra !!! code\_block time="2.161 ms" -```sql +```postgresql INSERT INTO search_result_clicks (title_rank, body_rank, clicked) VALUES @@ -289,7 +289,7 @@ Here goes some machine learning: !!! code\_block time="6.867 ms" -```sql +```postgresql SELECT * FROM pgml.train( project_name => 'Search Ranking', task => 'regression', @@ -336,7 +336,7 @@ Once a model is trained, you can use `pgml.predict` to use it on new inputs. `pg !!! code\_block time="3.119 ms" -```sql +```postgresql SELECT clicked, pgml.predict('Search Ranking', array[title_rank, body_rank]) @@ -389,7 +389,7 @@ It's nice to organize the query into logical steps, and we can use **Common Tabl !!! code\_block time="2.118 ms" -```sql +```postgresql WITH first_pass_ranked_documents AS ( SELECT -- Compute the ts_rank for the title and body text of each document diff --git a/pgml-cms/blog/mindsdb-vs-postgresml.md b/pgml-cms/blog/mindsdb-vs-postgresml.md index 9b92bd851..6459d2d9e 100644 --- a/pgml-cms/blog/mindsdb-vs-postgresml.md +++ b/pgml-cms/blog/mindsdb-vs-postgresml.md @@ -94,7 +94,7 @@ For both implementations, we can just pass in our data as part of the query for !!! code\_block time="4769.337 ms" -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I am so excited to benchmark deep learning models in SQL. I can not wait to see the results!' @@ -124,7 +124,7 @@ The first time `transform` is run with a particular model name, it will download !!! code\_block time="45.094 ms" -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I don''t really know if 5 seconds is fast or slow for deep learning. How much time is spent downloading vs running the model?' @@ -154,7 +154,7 @@ SELECT pgml.transform( !!! code\_block time="165.036 ms" -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'Are GPUs really worth it? Sometimes they are more expensive than the rest of the computer combined.' @@ -209,7 +209,7 @@ psql postgres://mindsdb:123@127.0.0.1:55432 And turn timing on to see how long it takes to run the same query: -```sql +```postgresql \timing on ``` diff --git a/pgml-cms/blog/pg-stat-sysinfo-a-postgres-extension-for-querying-system-statistics.md b/pgml-cms/blog/pg-stat-sysinfo-a-postgres-extension-for-querying-system-statistics.md index bb14ff2dd..b50572ea0 100644 --- a/pgml-cms/blog/pg-stat-sysinfo-a-postgres-extension-for-querying-system-statistics.md +++ b/pgml-cms/blog/pg-stat-sysinfo-a-postgres-extension-for-querying-system-statistics.md @@ -62,7 +62,7 @@ All system statistics are stored together in this one structure. !!! code\_block -```sql +```postgresql SELECT * FROM pg_stat_sysinfo WHERE metric = 'load_average' AND at BETWEEN '2023-04-07 19:20:09.3' @@ -97,7 +97,7 @@ In the case of the load average, we could handle this situation by having a tabl !!! code\_block -```sql +```postgresql CREATE TABLE load_average ( at timestamptz NOT NULL DEFAULT now(), "1m" float4 NOT NULL, @@ -112,7 +112,7 @@ This structure is fine for `load_average` but wouldn't work for CPU, disk, RAM o !!! code\_block -```sql +```postgresql CREATE TABLE load_average ( at timestamptz NOT NULL DEFAULT now(), "1m" float4 NOT NULL, @@ -132,7 +132,7 @@ This has the disadvantage of baking in a lot of keys and the overall structure o !!! code\_block -```sql +```postgresql CREATE TABLE load_average ( at timestamptz NOT NULL DEFAULT now(), "1m" float4 NOT NULL, diff --git a/pgml-cms/blog/postgres-full-text-search-is-awesome.md b/pgml-cms/blog/postgres-full-text-search-is-awesome.md index c1cab12b5..4ef6e9db8 100644 --- a/pgml-cms/blog/postgres-full-text-search-is-awesome.md +++ b/pgml-cms/blog/postgres-full-text-search-is-awesome.md @@ -54,7 +54,7 @@ These queries can execute in milliseconds on large production-sized corpora with The following full blown example is for demonstration purposes only of a 3rd generation search engine. You can test it for real in the PostgresML Gym to build up a complete understanding. -```sql +```postgresql WITH query AS ( -- construct a query context with arguments that would typically be -- passed in from the application layer diff --git a/pgml-cms/blog/postgresml-is-moving-to-rust-for-our-2.0-release.md b/pgml-cms/blog/postgresml-is-moving-to-rust-for-our-2.0-release.md index 623d3e006..eff3ee084 100644 --- a/pgml-cms/blog/postgresml-is-moving-to-rust-for-our-2.0-release.md +++ b/pgml-cms/blog/postgresml-is-moving-to-rust-for-our-2.0-release.md @@ -27,7 +27,7 @@ Python is generally touted as fast enough for machine learning, and is the de fa To illustrate our motivation, we'll create a test set of 10,000 random embeddings with 128 dimensions, and store them in a table. Our first benchmark will simulate semantic ranking, by computing the dot product against every member of the test set, sorting the results and returning the top match. -```sql +```postgresql -- Generate 10,000 embeddings with 128 dimensions as FLOAT4[] type. CREATE TABLE embeddings AS SELECT ARRAY_AGG(random())::FLOAT4[] AS vector @@ -39,7 +39,7 @@ Spoiler alert: idiomatic Rust is about 10x faster than native SQL, embedded PL/p {% tabs %} {% tab title="SQL" %} -```sql +```postgresql CREATE OR REPLACE FUNCTION dot_product_sql(a FLOAT4[], b FLOAT4[]) RETURNS FLOAT4 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS @@ -49,7 +49,7 @@ $$ $$; ``` -```sql +```postgresql WITH test AS ( SELECT ARRAY_AGG(random())::FLOAT4[] AS vector FROM generate_series(1, 128) i @@ -62,7 +62,7 @@ LIMIT 1; {% endtab %} {% tab title="PL/pgSQL" %} -```sql +```postgresql CREATE OR REPLACE FUNCTION dot_product_plpgsql(a FLOAT4[], b FLOAT4[]) RETURNS FLOAT4 LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE AS @@ -74,7 +74,7 @@ $$ $$; ``` -```sql +```postgresql WITH test AS ( SELECT ARRAY_AGG(random())::FLOAT4[] AS vector FROM generate_series(1, 128) i @@ -87,7 +87,7 @@ LIMIT 1; {% endtab %} {% tab title="Python" %} -```sql +```postgresql CREATE OR REPLACE FUNCTION dot_product_python(a FLOAT4[], b FLOAT4[]) RETURNS FLOAT4 LANGUAGE plpython3u IMMUTABLE STRICT PARALLEL SAFE AS @@ -96,7 +96,7 @@ $$ $$; ``` -```sql +```postgresql WITH test AS ( SELECT ARRAY_AGG(random())::FLOAT4[] AS vector FROM generate_series(1, 128) i @@ -109,7 +109,7 @@ LIMIT 1; {% endtab %} {% tab title="NumPy" %} -```sql +```postgresql CREATE OR REPLACE FUNCTION dot_product_numpy(a FLOAT4[], b FLOAT4[]) RETURNS FLOAT4 LANGUAGE plpython3u IMMUTABLE STRICT PARALLEL SAFE AS @@ -119,7 +119,7 @@ $$ $$; ``` -```sql +```postgresql WITH test AS ( SELECT ARRAY_AGG(random())::FLOAT4[] AS vector FROM generate_series(1, 128) i @@ -144,7 +144,7 @@ fn dot_product_rust(vector: Vec, other: Vec) -> f32 { } ``` -```sql +```postgresql WITH test AS ( SELECT ARRAY_AGG(random())::FLOAT4[] AS vector FROM generate_series(1, 128) i @@ -203,7 +203,7 @@ The results are somewhat staggering. We didn't spend any time intentionally opti ## Preserving Backward Compatibility -```sql +```postgresql SELECT pgml.train( project_name => 'Handwritten Digit Classifier', task => 'classification', @@ -213,7 +213,7 @@ SELECT pgml.train( ); ``` -```sql +```postgresql SELECT pgml.predict('Handwritten Digit Classifier', image) FROM pgml.digits; ``` diff --git a/pgml-cms/blog/sentiment-analysis-using-express-js-and-postgresml.md b/pgml-cms/blog/sentiment-analysis-using-express-js-and-postgresml.md index 73407bcf7..56f836db3 100644 --- a/pgml-cms/blog/sentiment-analysis-using-express-js-and-postgresml.md +++ b/pgml-cms/blog/sentiment-analysis-using-express-js-and-postgresml.md @@ -65,7 +65,7 @@ We also have three endpoints to hit: * `app.get(“/", async (req, res, next)` which returns all the notes for that day and the daily summary. * `app.post(“/add", async (req, res, next)` which accepts a new note entry and performs a sentiment analysis. We simplify the score by converting it to 1, 0, -1 for positive, neutral, negative and save it in our notes table. -```sql +```postgresql WITH note AS ( SELECT pgml.transform( inputs => ARRAY['${req.body.note}'], @@ -88,7 +88,7 @@ INSERT INTO notes (note, score) VALUES ('${req.body.note}', (SELECT score FROM s * `app.get(“/analyze”, async (req, res, next)` which takes the daily entries, produces a summary and total sentiment score, and places that into our days table. -```sql +```postgresql WITH day AS ( SELECT note, diff --git a/pgml-cms/blog/the-1.0-sdk-is-here.md b/pgml-cms/blog/the-1.0-sdk-is-here.md index 185f0d438..94464d566 100644 --- a/pgml-cms/blog/the-1.0-sdk-is-here.md +++ b/pgml-cms/blog/the-1.0-sdk-is-here.md @@ -119,7 +119,7 @@ print(results) The SQL for the vector\_search is actually just: -```sql +```postgresql WITH "pipeline" ( "schema" ) AS ( diff --git a/pgml-cms/blog/which-database-that-is-the-question.md b/pgml-cms/blog/which-database-that-is-the-question.md index 2f9908807..bc0835a27 100644 --- a/pgml-cms/blog/which-database-that-is-the-question.md +++ b/pgml-cms/blog/which-database-that-is-the-question.md @@ -57,7 +57,7 @@ Most importantly though, Postgres allows you to understand your data and your bu Understanding your business is good, but what if you could improve it too? Most are tempted to throw spaghetti against the wall (and that's okay), but machine learning allows for a more scientific approach. Traditionally, ML has been tough to use with modern data architectures: using key-value databases makes data virtually inaccessible in bulk. With PostgresML though, you can train an XGBoost model directly on your orders table with a single SQL query: -```sql +```postgresql SELECT pgml.train( 'Orders Likely To Be Returned', -- name of your model 'regression', -- objective (regression or classification) diff --git a/pgml-cms/docs/README.md b/pgml-cms/docs/README.md index 1d993a933..fe5f9df15 100644 --- a/pgml-cms/docs/README.md +++ b/pgml-cms/docs/README.md @@ -4,7 +4,7 @@ description: The key concepts that make up PostgresML. # Overview -PostgresML is a complete MLOps platform built on PostgreSQL. Our operating principle is: +PostgresML is a complete MLOps platform built inside PostgreSQL. Our operating principle is: > _Move models to the database, rather than constantly moving data to the models._ diff --git a/pgml-cms/docs/SUMMARY.md b/pgml-cms/docs/SUMMARY.md index 6c463d16c..e207aa1be 100644 --- a/pgml-cms/docs/SUMMARY.md +++ b/pgml-cms/docs/SUMMARY.md @@ -51,6 +51,67 @@ * [Semantic Search](api/client-sdk/tutorials/semantic-search.md) * [Semantic Search Using Instructor Model](api/client-sdk/tutorials/semantic-search-1.md) +## Guides + +* [Embeddings](guides/embeddings/README.md) + * [In-database Generation](guides/embeddings/in-database-generation.md) + * [Dimensionality Reduction](guides/embeddings/dimensionality-reduction.md) + * [Aggregation](guides/embeddings/vector-aggregation.md) + * [Similarity](guides/embeddings/vector-similarity.md) + * [Normalization](guides/embeddings/vector-normalization.md) + + + +* [Search](guides/improve-search-results-with-machine-learning.md) +* [Chatbots](guides/chatbots/README.md) + * [Example Application](use-cases/chatbots.md) +* [Supervised Learning](guides/supervised-learning.md) +* [OpenSourceAI](guides/opensourceai.md) +* [Natural Language Processing](guides/natural-language-processing.md) + + + ## Product * [Cloud database](product/cloud-database/README.md) @@ -63,21 +124,6 @@ * [Installation](product/pgcat/installation.md) * [Configuration](product/pgcat/configuration.md) -## Use Cases - -* [OpenSourceAI](use-cases/opensourceai.md) -* [Chatbots](use-cases/chatbots/README.md) - * [Example Application](use-cases/chatbots.md) -* [Search](use-cases/improve-search-results-with-machine-learning.md) -* [Embeddings](use-cases/embeddings/README.md) - * [Generating LLM embeddings with open source models](use-cases/embeddings/generating-llm-embeddings-with-open-source-models-in-postgresml.md) - * [Tuning vector recall while generating query embeddings in the database](use-cases/embeddings/tuning-vector-recall-while-generating-query-embeddings-in-the-database.md) - * [Personalize embedding results with application data in your database](use-cases/embeddings/personalize-embedding-results-with-application-data-in-your-database.md) -* [Supervised Learning](use-cases/supervised-learning.md) -* [Natural Language Processing](use-cases/natural-language-processing.md) -* [Fraud Detection](use-cases/fraud-detection.md) -* [Recommendation Engine](use-cases/recommendation-engine.md) -* [Time-series Forecasting](use-cases/time-series-forecasting.md) ## Resources diff --git a/pgml-cms/docs/api/sql-extension/pgml.chunk.md b/pgml-cms/docs/api/sql-extension/pgml.chunk.md index fa2380057..897889f89 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.chunk.md +++ b/pgml-cms/docs/api/sql-extension/pgml.chunk.md @@ -8,7 +8,7 @@ Chunks are pieces of documents split using some specified splitter. This is typi ## API -```sql +```postgresql pgml.chunk( splitter TEXT, -- splitter name text TEXT, -- text to embed @@ -18,21 +18,21 @@ pgml.chunk( ## Example -```sql +```postgresql SELECT pgml.chunk('recursive_character', 'test'); ``` -```sql +```postgresql SELECT pgml.chunk('recursive_character', 'test', '{"chunk_size": 1000, "chunk_overlap": 40}'::jsonb); ``` -```sql +```postgresql SELECT pgml.chunk('markdown', '# Some test'); ``` Note that the input text for those splitters is so small it isn't splitting it at all, a real world example would look more like: -```sql +```postgresql SELECT pgml.chunk('recursive_character', content) FROM documents; ``` diff --git a/pgml-cms/docs/api/sql-extension/pgml.decompose.md b/pgml-cms/docs/api/sql-extension/pgml.decompose.md index 9e1f37484..16d4dfd46 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.decompose.md +++ b/pgml-cms/docs/api/sql-extension/pgml.decompose.md @@ -4,11 +4,11 @@ description: Decompose an input vector into it's principal components # pgml.decompose() -Matrix decomposition reduces the number of dimensions in a vector, to improve relevance and reduce computation required. +Matrix decomposition reduces the number of dimensions in a vector, to improve relevance and reduce computation required. ## API -```sql +```postgresql pgml.decompose( project_name TEXT, -- project name vector REAL[] -- features to decompose @@ -17,13 +17,13 @@ pgml.decompose( ### Parameters -| Parameter | Example | Description | -|----------------|---------------------------------|----------------------------------------------------------| -| `project_name` | `'My First PostgresML Project'` | The project name used to train models in `pgml.train()`. | -| `vector` | `ARRAY[0.1, 0.45, 1.0]` | The feature vector to transform. | +| Parameter | Example | Description | +|----------------|---------------------------------|-------------------------------------------------------------------------| +| `project_name` | `'My First PostgresML Project'` | The project name used to train a decomposition model in `pgml.train()`. | +| `vector` | `ARRAY[0.1, 0.45, 1.0]` | The feature vector to transform. | ## Example -```sql +```postgresql SELECT pgml.decompose('My PCA', ARRAY[0.1, 2.0, 5.0]); ``` diff --git a/pgml-cms/docs/api/sql-extension/pgml.deploy.md b/pgml-cms/docs/api/sql-extension/pgml.deploy.md index 3181f9d51..645d99e6e 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.deploy.md +++ b/pgml-cms/docs/api/sql-extension/pgml.deploy.md @@ -12,7 +12,7 @@ A model is automatically deployed and used for predictions if its key metric (_R ## API -```sql +```postgresql pgml.deploy( project_name TEXT, strategy TEXT DEFAULT 'best_score', @@ -46,7 +46,7 @@ The default deployment behavior allows any algorithm to qualify. It's automatica #### SQL -```sql +```postgresql SELECT * FROM pgml.deploy( 'Handwritten Digit Image Classifier', strategy => 'best_score' @@ -55,7 +55,7 @@ SELECT * FROM pgml.deploy( #### Output -```sql +```postgresql project | strategy | algorithm ------------------------------------+------------+----------- Handwritten Digit Image Classifier | best_score | xgboost @@ -68,7 +68,7 @@ Deployment candidates can be restricted to a specific algorithm by including the #### SQL -```sql +```postgresql SELECT * FROM pgml.deploy( project_name => 'Handwritten Digit Image Classifier', strategy => 'best_score', @@ -78,7 +78,7 @@ SELECT * FROM pgml.deploy( #### Output -```sql +```postgresql project_name | strategy | algorithm ------------------------------------+----------------+---------------- Handwritten Digit Image Classifier | classification | svm @@ -91,7 +91,7 @@ In case the new model isn't performing well in production, it's easy to rollback #### Rollback -```sql +```postgresql SELECT * FROM pgml.deploy( 'Handwritten Digit Image Classifier', strategy => 'rollback' @@ -100,7 +100,7 @@ SELECT * FROM pgml.deploy( #### Output -```sql +```postgresql project | strategy | algorithm ------------------------------------+----------+----------- Handwritten Digit Image Classifier | rollback | linear @@ -111,7 +111,7 @@ SELECT * FROM pgml.deploy( Rollbacks are actually new deployments, so issuing two rollbacks in a row will leave you back with the original model, making rollback safely undoable. -```sql +```postgresql SELECT * FROM pgml.deploy( 'Handwritten Digit Image Classifier', strategy => 'rollback' @@ -120,7 +120,7 @@ SELECT * FROM pgml.deploy( #### Output -```sql +```postgresql project | strategy | algorithm ------------------------------------+----------+----------- Handwritten Digit Image Classifier | rollback | xgboost @@ -133,13 +133,13 @@ In the case you need to deploy an exact model that is not the `most_recent` or ` #### SQL -```sql +```postgresql SELECT * FROM pgml.deploy(12); ``` #### Output -```sql +```postgresql project | strategy | algorithm ------------------------------------+----------+----------- Handwritten Digit Image Classifier | specific | xgboost diff --git a/pgml-cms/docs/api/sql-extension/pgml.embed.md b/pgml-cms/docs/api/sql-extension/pgml.embed.md index 1f9b946b5..43da6120e 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.embed.md +++ b/pgml-cms/docs/api/sql-extension/pgml.embed.md @@ -10,7 +10,7 @@ The `pgml.embed()` function generates [embeddings](/docs/use-cases/embeddings/) ## API -```sql +```postgresql pgml.embed( transformer TEXT, "text" TEXT, @@ -34,10 +34,10 @@ Creating an embedding from text is as simple as calling the function with the te {% tab title="SQL" %} ```postgresql -SELECT * FROM pgml.embed( - 'intfloat/e5-small', +SELECT pgml.embed( + 'intfloat/e5-small-v2', 'No, that''s not true, that''s impossible.' -) AS star_wars_embedding; +); ``` {% endtab %} @@ -47,52 +47,35 @@ SELECT * FROM pgml.embed( SQL functions can be used as part of a query to insert, update, or even automatically generate column values of any table: -{% tabs %} -{% tab title="SQL" %} - ```postgresql CREATE TABLE star_wars_quotes ( quote TEXT NOT NULL, embedding vector(384) GENERATED ALWAYS AS ( - pgml.embed('intfloat/e5-small', quote) + pgml.embed('intfloat/e5-small-v2', quote) ) STORED ); -INSERT INTO - star_wars_quotes (quote) +INSERT INTO star_wars_quotes (quote) VALUES -('I find your lack of faith disturbing'), -('I''ve got a bad feeling about this.'), -('Do or do not, there is no try.'); + ('I find your lack of faith disturbing'), + ('I''ve got a bad feeling about this.'), + ('Do or do not, there is no try.'); ``` -{% endtab %} -{% endtabs %} - In this example, we're using [generated columns](https://www.postgresql.org/docs/current/ddl-generated-columns.html) to automatically create an embedding of the `quote` column every time the column value is updated. #### Using embeddings in queries Once you have embeddings, you can use them in queries to find text with similar semantic meaning: -{% tabs %} -{% tab title="SQL" %} - ```postgresql -SELECT - quote -FROM - star_wars_quotes -ORDER BY - pgml.embed( - 'intfloat/e5-small', +SELECT quote +FROM star_wars_quotes +ORDER BY pgml.embed( + 'intfloat/e5-small-v2', 'Feel the force!', - ) <=> embedding - DESC + ) <=> embedding DESC LIMIT 1; ``` -{% endtab %} -{% endtabs %} - This query will return the quote with the most similar meaning to `'Feel the force!'` by generating an embedding of that quote and comparing it to all other embeddings in the table, using vector cosine similarity as the measure of distance. diff --git a/pgml-cms/docs/api/sql-extension/pgml.predict/README.md b/pgml-cms/docs/api/sql-extension/pgml.predict/README.md index ffcfc3043..71fed7a6c 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.predict/README.md +++ b/pgml-cms/docs/api/sql-extension/pgml.predict/README.md @@ -10,7 +10,7 @@ description: >- The `pgml.predict()` function is the key value proposition of PostgresML. It provides online predictions using the best, automatically deployed model for a project. The API for predictions is very simple and only requires two arguments: the project name and the features used for prediction. -```sql +```postgresql select pgml.predict ( project_name TEXT, features REAL[] @@ -26,7 +26,7 @@ select pgml.predict ( ### Regression Example -```sql +```postgresql SELECT pgml.predict( 'My Classification Project', ARRAY[0.1, 2.0, 5.0] @@ -37,7 +37,7 @@ where `ARRAY[0.1, 2.0, 5.0]` is the same type of features used in training, in t !!! example -```sql +```postgresql SELECT *, pgml.predict( 'Buy it Again', @@ -59,7 +59,7 @@ LIMIT 25; If you've already been through the [pgml.train](../pgml.train "mention") examples, you can see the predictive results of those models: -```sql +```postgresql SELECT target, pgml.predict('Handwritten Digit Image Classifier', image) AS prediction @@ -67,7 +67,7 @@ FROM pgml.digits LIMIT 10; ``` -```sql +```postgresql target | prediction --------+------------ 0 | 0 @@ -87,11 +87,11 @@ LIMIT 10; Since it's so easy to train multiple algorithms with different hyperparameters, sometimes it's a good idea to know which deployed model is used to make predictions. You can find that out by querying the `pgml.deployed_models` view: -```sql +```postgresql SELECT * FROM pgml.deployed_models; ``` -```sql +```postgresql id | name | task | algorithm | runtime | deployed_at ----+------------------------------------+----------------+-----------+---------+---------------------------- 4 | Handwritten Digit Image Classifier | classification | xgboost | rust | 2022-10-11 13:06:26.473489 @@ -106,7 +106,7 @@ Take a look at [pgml.deploy.md](../pgml.deploy.md "mention") for more details. You may also specify a model\_id to predict rather than a project name, to use a particular training run. You can find model ids by querying the `pgml.models` table. -```sql +```postgresql SELECT models.id, models.algorithm, models.metrics FROM pgml.models JOIN pgml.projects @@ -114,7 +114,7 @@ JOIN pgml.projects WHERE projects.name = 'Handwritten Digit Image Classifier'; ``` -```sql +```postgresql id | algorithm | metrics ----+-----------+------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -125,7 +125,7 @@ recision": 0.9175060987472534, "score_time": 0.019625699147582054} For example, making predictions with `model_id = 1`: -```sql +```postgresql SELECT target, pgml.predict(1, image) AS prediction diff --git a/pgml-cms/docs/api/sql-extension/pgml.predict/batch-predictions.md b/pgml-cms/docs/api/sql-extension/pgml.predict/batch-predictions.md index 3f45c71c3..442454c27 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.predict/batch-predictions.md +++ b/pgml-cms/docs/api/sql-extension/pgml.predict/batch-predictions.md @@ -10,7 +10,7 @@ Many machine learning algorithms can benefit from calculating predictions in one The API for batch predictions is very similar to individual predictions, and only requires two arguments: the project name and the _aggregated_ features used for predictions. -```sql +```postgresql pgml.predict_batch( project_name TEXT, features REAL[] @@ -26,7 +26,7 @@ pgml.predict_batch( !!! example -```sql +```postgresql SELECT pgml.predict_batch( 'My First PostgresML Project', array_agg(ARRAY[0.1, 2.0, 5.0]) @@ -44,7 +44,7 @@ Batch predictions have to be fetched in a subquery or a CTE because they are usi \=== "SQL" -```sql +```postgresql WITH predictions AS ( SELECT pgml.predict_batch( 'My Classification Project', @@ -62,7 +62,7 @@ LIMIT 10; \=== "Output" -```sql +```postgresql prediction | target ------------+-------- 0 | 0 @@ -88,7 +88,7 @@ To perform a join on batch predictions, it's necessary to have a uniquely identi **Example** -```sql +```postgresql WITH predictions AS ( SELECT -- diff --git a/pgml-cms/docs/api/sql-extension/pgml.train/README.md b/pgml-cms/docs/api/sql-extension/pgml.train/README.md index ec49916cc..9a8507ea9 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.train/README.md +++ b/pgml-cms/docs/api/sql-extension/pgml.train/README.md @@ -12,7 +12,7 @@ The training function is at the heart of PostgresML. It's a powerful single mech Most parameters are optional and have configured defaults. The `project_name` parameter is required and is an easily recognizable identifier to organize your work. -```sql +```postgresql pgml.train( project_name TEXT, task TEXT DEFAULT NULL, @@ -48,7 +48,7 @@ pgml.train( !!! example -```sql +```postgresql SELECT * FROM pgml.train( project_name => 'My Classification Project', task => 'classification', @@ -67,7 +67,7 @@ The first time it's called, the function will also require a `relation_name` and !!! tip -```sql +```postgresql SELECT * FROM pgml.train( 'My Classification Project', algorithm => 'xgboost' diff --git a/pgml-cms/docs/api/sql-extension/pgml.train/classification.md b/pgml-cms/docs/api/sql-extension/pgml.train/classification.md index 24df21c49..82cc2f967 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.train/classification.md +++ b/pgml-cms/docs/api/sql-extension/pgml.train/classification.md @@ -10,7 +10,7 @@ description: >- This example trains models on the sklean digits dataset which is a copy of the test set of the [UCI ML hand-written digits datasets](https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits). This demonstrates using a table with a single array feature column for classification. You could do something similar with a vector column. -```sql +```postgresql -- load the sklearn digits dataset SELECT pgml.load_dataset('digits'); @@ -46,7 +46,7 @@ We currently support classification algorithms from [scikit-learn](https://sciki #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'xgboost', hyperparams => '{"n_estimators": 10}'); SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'xgboost_random_forest', hyperparams => '{"n_estimators": 10}'); SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'lightgbm', hyperparams => '{"n_estimators": 1}'); @@ -66,7 +66,7 @@ SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'catboost', hyperpar #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'ada_boost'); SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'bagging'); SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'extra_trees', hyperparams => '{"n_estimators": 10}'); @@ -85,7 +85,7 @@ SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'hist_gradient_boost #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'svm'); SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'nu_svm'); SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'linear_svm'); @@ -103,7 +103,7 @@ SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'linear_svm'); #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'ridge'); SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'stochastic_gradient_descent'); SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'perceptron'); @@ -118,6 +118,6 @@ SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'passive_aggressive' #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Handwritten Digits', algorithm => 'gaussian_process', hyperparams => '{"max_iter_predict": 100, "warm_start": true}'); ``` diff --git a/pgml-cms/docs/api/sql-extension/pgml.train/clustering.md b/pgml-cms/docs/api/sql-extension/pgml.train/clustering.md index 5ecf0b552..5c0558dd7 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.train/clustering.md +++ b/pgml-cms/docs/api/sql-extension/pgml.train/clustering.md @@ -6,7 +6,7 @@ Models can be trained using `pgml.train` on unlabeled data to identify groups wi This example trains models on the sklearn digits dataset -- which is a copy of the test set of the [UCI ML hand-written digits datasets](https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits). This demonstrates using a table with a single array feature column for clustering. You could do something similar with a vector column. -```sql +```postgresql SELECT pgml.load_dataset('digits'); -- create an unlabeled table of the images for unsupervised learning @@ -38,7 +38,7 @@ All clustering algorithms implemented by PostgresML are online versions. You may ### Examples -```sql +```postgresql SELECT * FROM pgml.train('Handwritten Digit Clusters', algorithm => 'affinity_propagation'); SELECT * FROM pgml.train('Handwritten Digit Clusters', algorithm => 'birch', hyperparams => '{"n_clusters": 10}'); SELECT * FROM pgml.train('Handwritten Digit Clusters', algorithm => 'kmeans', hyperparams => '{"n_clusters": 10}'); diff --git a/pgml-cms/docs/api/sql-extension/pgml.train/data-pre-processing.md b/pgml-cms/docs/api/sql-extension/pgml.train/data-pre-processing.md index 683343309..551e287f3 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.train/data-pre-processing.md +++ b/pgml-cms/docs/api/sql-extension/pgml.train/data-pre-processing.md @@ -31,7 +31,7 @@ There are 3 steps to preprocessing data: These preprocessing steps may be specified on a per-column basis to the [train()](./) function. By default, PostgresML does minimal preprocessing on training data, and will raise an error during analysis if NULL values are encountered without a preprocessor. All types other than `TEXT` are treated as quantitative variables and cast to floating point representations before passing them to the underlying algorithm implementations. -```sql +```postgresql SELECT pgml.train( project_name => 'preprocessed_model', task => 'classification', @@ -60,7 +60,7 @@ In some cases, it may make sense to use multiple steps for a single column. For A model that has been trained with preprocessors should use a Postgres tuple for prediction, rather than a `FLOAT4[]`. Tuples may contain multiple different types (like `TEXT` and `BIGINT`), while an ARRAY may only contain a single type. You can use parenthesis around values to create a Postgres tuple. -```sql +```postgresql SELECT pgml.predict('preprocessed_model', ('jan', 'nimbus', 0.5, 7)); ``` @@ -79,7 +79,7 @@ Encoding categorical variables is an O(N log(M)) where N is the number of rows, Target encoding is a relatively efficient way to represent a categorical variable. The average value of the target is computed for each category in the training data set. It is reasonable to `scale` target encoded variables using the same method as other variables. -```sql +```postgresql preprocess => '{ "clouds": {"encode": "target" } }' @@ -131,7 +131,7 @@ preprocess => '{ | `max` | the maximum value of the variable in the training data set | | `zero` | replaces all missing values with 0.0 | -```sql +```postgresql preprocess => '{ "temp": {"impute": "mean"} }' @@ -149,7 +149,7 @@ Scaling all variables to a standardized range can help make sure that no feature | `max_abs` | Scales data from -1.0 to +1.0. Data will not be centered around 0, unless abs(min) == abs(max). | | `robust` | Scales data as a factor of the first and third quartiles. This method may handle outliers more robustly than others. | -```sql +```postgresql preprocess => '{ "temp": {"scale": "standard"} }' diff --git a/pgml-cms/docs/api/sql-extension/pgml.train/decomposition.md b/pgml-cms/docs/api/sql-extension/pgml.train/decomposition.md index be8420df2..abe3b88ef 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.train/decomposition.md +++ b/pgml-cms/docs/api/sql-extension/pgml.train/decomposition.md @@ -6,7 +6,7 @@ Models can be trained using `pgml.train` on unlabeled data to identify important This example trains models on the sklearn digits dataset -- which is a copy of the test set of the [UCI ML hand-written digits datasets](https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits). This demonstrates using a table with a single array feature column for principal component analysis. You could do something similar with a vector column. -```sql +```postgresql SELECT pgml.load_dataset('digits'); -- create an unlabeled table of the images for unsupervised learning @@ -37,6 +37,6 @@ All decomposition algorithms implemented by PostgresML are online versions. You ### Examples -```sql +```postgresql SELECT * FROM pgml.train('Handwritten Digit Clusters', algorithm => 'pca', hyperparams => '{"n_components": 10}'); ``` diff --git a/pgml-cms/docs/api/sql-extension/pgml.train/hyperparameter-search.md b/pgml-cms/docs/api/sql-extension/pgml.train/hyperparameter-search.md index 4461963f1..8b0788f98 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.train/hyperparameter-search.md +++ b/pgml-cms/docs/api/sql-extension/pgml.train/hyperparameter-search.md @@ -12,7 +12,7 @@ The parameters passed to `pgml.train()` easily allow one to perform hyperparamet | `search_params` | `{"alpha": [0.1, 0.2, 0.5] }` | | `search_args` | `{"n_iter": 10 }` | -```sql +```postgresql SELECT * FROM pgml.train( 'Handwritten Digit Image Classifier', algorithm => 'xgboost', diff --git a/pgml-cms/docs/api/sql-extension/pgml.train/joint-optimization.md b/pgml-cms/docs/api/sql-extension/pgml.train/joint-optimization.md index b65812045..3ad397249 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.train/joint-optimization.md +++ b/pgml-cms/docs/api/sql-extension/pgml.train/joint-optimization.md @@ -4,7 +4,7 @@ Some algorithms support joint optimization of the task across multiple outputs, To leverage multiple outputs in PostgresML, you'll need to substitute the standard usage of `pgml.train()` with `pgml.train_joint()`, which has the same API, except the notable exception of `y_column_name` parameter, which now accepts an array instead of a simple string. -```sql +```postgresql SELECT * FROM pgml.train_join( 'My Joint Project', task => 'regression', diff --git a/pgml-cms/docs/api/sql-extension/pgml.train/regression.md b/pgml-cms/docs/api/sql-extension/pgml.train/regression.md index eb1a1d4de..9e9e8332c 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.train/regression.md +++ b/pgml-cms/docs/api/sql-extension/pgml.train/regression.md @@ -12,7 +12,7 @@ We currently support regression algorithms from [scikit-learn](https://scikit-le This example trains models on the sklean [diabetes dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load\_diabetes.html#sklearn.datasets.load\_diabetes). This example uses multiple input features to predict a single output variable. -```sql +```postgresql -- load the dataset SELECT pgml.load_dataset('diabetes'); @@ -41,7 +41,7 @@ LIMIT 10; #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'xgboost', hyperparams => '{"n_estimators": 10}'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'xgboost_random_forest', hyperparams => '{"n_estimators": 10}'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'lightgbm', hyperparams => '{"n_estimators": 1}'); @@ -61,7 +61,7 @@ SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'catboost', hyperp #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'ada_boost', hyperparams => '{"n_estimators": 5}'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'bagging', hyperparams => '{"n_estimators": 5}'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'extra_trees', hyperparams => '{"n_estimators": 5}'); @@ -80,7 +80,7 @@ SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'hist_gradient_boo #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'svm', hyperparams => '{"max_iter": 100}'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'nu_svm', hyperparams => '{"max_iter": 10}'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'linear_svm', hyperparams => '{"max_iter": 100}'); @@ -108,7 +108,7 @@ SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'linear_svm', hype #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'linear'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'ridge'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'lasso'); @@ -135,7 +135,7 @@ SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'quantile'); #### Examples -```sql +```postgresql SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'kernel_ridge'); SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'gaussian_process'); ``` diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/fill-mask.md b/pgml-cms/docs/api/sql-extension/pgml.transform/fill-mask.md index 07775258f..6202b59b5 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/fill-mask.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/fill-mask.md @@ -11,7 +11,7 @@ Fill-Mask is a task where certain words in a sentence are hidden or "masked", an {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "fill-mask" diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/question-answering.md b/pgml-cms/docs/api/sql-extension/pgml.transform/question-answering.md index 9dfd41246..861a5afc3 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/question-answering.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/question-answering.md @@ -11,7 +11,7 @@ Question answering models are designed to retrieve the answer to a question from {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( 'question-answering', inputs => ARRAY[ diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/summarization.md b/pgml-cms/docs/api/sql-extension/pgml.transform/summarization.md index b37a406ec..ec0171a17 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/summarization.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/summarization.md @@ -11,7 +11,7 @@ Summarization involves creating a condensed version of a document that includes {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "summarization", diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/text-classification.md b/pgml-cms/docs/api/sql-extension/pgml.transform/text-classification.md index eb670b267..e53f4952e 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/text-classification.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/text-classification.md @@ -15,7 +15,7 @@ Sentiment analysis is a type of natural language processing technique which anal {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => 'text-classification', inputs => ARRAY[ @@ -50,7 +50,7 @@ For example, if you want to use a RoBERTa model trained on around 40,000 English {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-classification", @@ -86,7 +86,7 @@ By selecting a model that has been specifically designed for a particular subjec {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-classification", @@ -131,7 +131,7 @@ If you want to use an NLI model, you can find them on the Hugging Face. When sea {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-classification", @@ -164,7 +164,7 @@ If you want to use an QNLI model, you can find them on the Hugging Face, by look {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-classification", @@ -197,7 +197,7 @@ If you want to use an QQP model, you can find them on Hugging Face, by looking f {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-classification", @@ -230,7 +230,7 @@ If you want to use a grammatical correctness model, you can find them on the Hug {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-classification", diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/text-generation.md b/pgml-cms/docs/api/sql-extension/pgml.transform/text-generation.md index 8d84ca762..d04ba910b 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/text-generation.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/text-generation.md @@ -6,7 +6,7 @@ description: Task of producing new text Text generation is the task of producing new text, such as filling in incomplete sentences or paraphrasing existing text. It has various use cases, including code generation and story generation. Completion generation models can predict the next word in a text sequence, while text-to-text generation models are trained to learn the mapping between pairs of texts, such as translating between languages. Popular models for text generation include GPT-based models, T5, T0, and BART. These models can be trained to accomplish a wide range of tasks, including text classification, summarization, and translation. -```sql +```postgresql SELECT pgml.transform( task => 'text-generation', inputs => ARRAY[ @@ -29,7 +29,7 @@ _Result_ To use a specific model from :hugging: model hub, pass the model name along with task name in task. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -53,7 +53,7 @@ _Result_ To make the generated text longer, you can include the argument `max_length` and specify the desired maximum length of the text. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -80,7 +80,7 @@ _Result_ If you want the model to generate more than one output, you can specify the number of desired output sequences by including the argument `num_return_sequences` in the arguments. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -111,7 +111,7 @@ _Result_ Text generation typically utilizes a greedy search algorithm that selects the word with the highest probability as the next word in the sequence. However, an alternative method called beam search can be used, which aims to minimize the possibility of overlooking hidden high probability word combinations. Beam search achieves this by retaining the num\_beams most likely hypotheses at each step and ultimately selecting the hypothesis with the highest overall probability. We set `num_beams > 1` and `early_stopping=True` so that generation is finished when all beam hypotheses reached the EOS token. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -143,7 +143,7 @@ You can pass `do_sample = True` in the arguments to use sampling methods. It is ### _Temperature_ -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", @@ -167,7 +167,7 @@ _Result_ ### _Top p_ -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text-generation", diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/text-to-text-generation.md b/pgml-cms/docs/api/sql-extension/pgml.transform/text-to-text-generation.md index dc97021c7..76ea9cf8d 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/text-to-text-generation.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/text-to-text-generation.md @@ -4,7 +4,7 @@ Text-to-text generation methods, such as T5, are neural network architectures de _Translation_ -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text2text-generation" @@ -25,7 +25,7 @@ _Result_ Similar to other tasks, we can specify a model for text-to-text generation. -```sql +```postgresql SELECT pgml.transform( task => '{ "task" : "text2text-generation", diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/token-classification.md b/pgml-cms/docs/api/sql-extension/pgml.transform/token-classification.md index 6f90a04fb..ed1e73507 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/token-classification.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/token-classification.md @@ -10,7 +10,7 @@ Token classification is a task in natural language understanding, where labels a Named Entity Recognition (NER) is a task that involves identifying named entities in a text. These entities can include the names of people, locations, or organizations. The task is completed by labeling each token with a class for each named entity and a class named "0" for tokens that don't contain any entities. In this task, the input is text, and the output is the annotated text with named entities. -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I am Omar and I live in New York City.' @@ -36,7 +36,7 @@ PoS tagging is a task that involves identifying the parts of speech, such as nou Look for models with `pos` to use a zero-shot classification model on the :hugs: Hugging Face model hub. -```sql +```postgresql select pgml.transform( inputs => array [ 'I live in Amsterdam.' diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/translation.md b/pgml-cms/docs/api/sql-extension/pgml.transform/translation.md index 874467b2f..0c0de9f2f 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/translation.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/translation.md @@ -6,7 +6,7 @@ description: Task of converting text written in one language into another langua Translation is the task of converting text written in one language into another language. You have the option to select from over 2000 models available on the Hugging Face [hub](https://huggingface.co/models?pipeline\_tag=translation) for translation. -```sql +```postgresql select pgml.transform( inputs => array[ 'How are you?' diff --git a/pgml-cms/docs/api/sql-extension/pgml.transform/zero-shot-classification.md b/pgml-cms/docs/api/sql-extension/pgml.transform/zero-shot-classification.md index 8d7e272e3..f0190e262 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.transform/zero-shot-classification.md +++ b/pgml-cms/docs/api/sql-extension/pgml.transform/zero-shot-classification.md @@ -10,7 +10,7 @@ In the example provided below, we will demonstrate how to classify a given sente Look for models with `mnli` to use a zero-shot classification model on the :hugs: Hugging Face model hub. -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I have a problem with my iphone that needs to be resolved asap!!' diff --git a/pgml-cms/docs/api/sql-extension/pgml.tune.md b/pgml-cms/docs/api/sql-extension/pgml.tune.md index 4c874893a..ec07b1242 100644 --- a/pgml-cms/docs/api/sql-extension/pgml.tune.md +++ b/pgml-cms/docs/api/sql-extension/pgml.tune.md @@ -16,7 +16,7 @@ The [Helsinki-NLP](https://huggingface.co/Helsinki-NLP) organization provides mo The [kde4](https://huggingface.co/datasets/kde4) dataset contains many language pairs. Subsets can be loaded into your Postgres instance with a call to `pgml.load_dataset`, or you may wish to create your own fine tuning dataset with vocabulary specific to your domain. -```sql +```postgresql SELECT pgml.load_dataset('kde4', kwargs => '{"lang1": "en", "lang2": "es"}'); ``` @@ -24,13 +24,13 @@ You can view the newly loaded data in your Postgres database: \=== "SQL" -```sql +```postgresql SELECT * FROM pgml.kde4 LIMIT 5; ``` \=== "Result" -```sql +```postgresql id | translation @@ -49,7 +49,7 @@ This HuggingFace dataset stores the data as language key pairs in a JSON documen \=== "SQL" -```sql +```postgresql CREATE OR REPLACE VIEW kde4_en_to_es AS SELECT translation->>'en' AS "en", translation->>'es' AS "es" FROM pgml.kde4 @@ -58,7 +58,7 @@ LIMIT 10; \=== "Result" -```sql +```postgresql CREATE VIEW ``` @@ -68,13 +68,13 @@ Now, we can see the data in more normalized form. The exact column names don't m \=== "SQL" -```sql +```postgresql SELECT * FROM kde4_en_to_es LIMIT 10; ``` \=== "Result" -```sql +```postgresql en | es --------------------------------------------------------------------------------------------+-------------------------------------------------------------------------- @@ -100,7 +100,7 @@ o de traducción de Babelfish. Tuning is very similar to training with PostgresML, although we specify a `model_name` to download from Hugging Face instead of the base `algorithm`. -```sql +```postgresql SELECT pgml.tune( 'Translate English to Spanish', task => 'translation', @@ -130,7 +130,7 @@ Translations use the `pgml.generate` API since they return `TEXT` rather than nu \=== "SQL" -```sql +```postgresql SELECT pgml.generate('Translate English to Spanish', 'I love SQL') AS spanish; @@ -138,7 +138,7 @@ AS spanish; \=== "Result" -```sql +```postgresql spanish ---------------- Me encanta SQL @@ -165,7 +165,7 @@ Once our model has been fine tuned on the dataset, it'll be saved and deployed w The IMDB dataset has 50,000 examples of user reviews with positive or negative viewing experiences as the labels, and is split 50/50 into training and evaluation datasets. -```sql +```postgresql SELECT pgml.load_dataset('imdb'); ``` @@ -173,13 +173,13 @@ You can view the newly loaded data in your Postgres database: \=== "SQL" -```sql +```postgresql SELECT * FROM pgml.imdb LIMIT 1; ``` \=== "Result" -```sql +```postgresql text | label -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------- This has to be the funniest stand up comedy I have ever seen. Eddie Izzard is a genius, he picks in Brits, Americans and everyone in between. His style is completely natural and completely hilarious. I doubt that anyone could sit through this and not laugh their a** off. Watch, enjoy, it's funny. | 1 @@ -192,7 +192,7 @@ SELECT * FROM pgml.imdb LIMIT 1; Tuning has a nearly identical API to training, except you may pass the name of a [model published on Hugging Face](https://huggingface.co/models) to start with, rather than training an algorithm from scratch. -```sql +```postgresql SELECT pgml.tune( 'IMDB Review Sentiment', task => 'text-classification', @@ -215,14 +215,14 @@ SELECT pgml.tune( \=== "SQL" -```sql +```postgresql SELECT pgml.predict('IMDB Review Sentiment', 'I love SQL') AS sentiment; ``` \=== "Result" -```sql +```postgresql sentiment ----------- 1 @@ -237,14 +237,14 @@ The default for predict in a classification problem classifies the statement as \=== "SQL" -```sql +```postgresql SELECT pgml.predict_proba('IMDB Review Sentiment', 'I love SQL') AS sentiment; ``` \=== "Result" -```sql +```postgresql sentiment ------------------------------------------- [0.06266672909259796, 0.9373332858085632] @@ -267,7 +267,7 @@ At a high level, summarization uses similar techniques to translation. Both use [BillSum](https://huggingface.co/datasets/billsum) is a dataset with training examples that summarize US Congressional and California state bills. You can pass `kwargs` specific to loading datasets, in this case we'll restrict the dataset to California samples: -```sql +```postgresql SELECT pgml.load_dataset('billsum', kwargs => '{"split": "ca_test"}'); ``` @@ -275,7 +275,7 @@ You can view the newly loaded data in your Postgres database: \=== "SQL" -```sql +```postgresql SELECT * FROM pgml.billsum LIMIT 1; ``` @@ -362,14 +362,14 @@ This act provides for a tax levy within the meaning of Article IV of the Constit This dataset has 3 fields, but summarization transformers only take a single input to produce their output. We can create a view that simply omits the `title` from the training data: -```sql +```postgresql CREATE OR REPLACE VIEW billsum_training_data AS SELECT "text", summary FROM pgml.billsum; ``` Or, it might be interesting to concat the title to the text field to see how relevant it actually is to the bill. If the title of a bill is the first sentence, and doesn't appear in summary, it may indicate that it's a poorly chosen title for the bill: -```sql +```postgresql CREATE OR REPLACE VIEW billsum_training_data AS SELECT title || '\n' || "text" AS "text", summary FROM pgml.billsum LIMIT 10; @@ -379,7 +379,7 @@ LIMIT 10; Tuning has a nearly identical API to training, except you may pass the name of a [model published on Hugging Face](https://huggingface.co/models) to start with, rather than training an algorithm from scratch. -```sql +```postgresql SELECT pgml.tune( 'Legal Summarization', task => 'summarization', @@ -403,13 +403,13 @@ SELECT pgml.tune( \=== "SQL" -```sql +```postgresql SELECT pgml.predict('IMDB Review Sentiment', 'I love SQL') AS sentiment; ``` \=== "Result" -```sql +```postgresql sentiment ----------- 1 @@ -424,13 +424,13 @@ The default for predict in a classification problem classifies the statement as \=== "SQL" -```sql +```postgresql SELECT pgml.predict_proba('IMDB Review Sentiment', 'I love SQL') AS sentiment; ``` \=== "Result" -```sql +```postgresql sentiment ------------------------------------------- [0.06266672909259796, 0.9373332858085632] @@ -447,7 +447,7 @@ See the [task documentation](https://huggingface.co/tasks/text-classification) f ### Text Generation -```sql +```postgresql SELECT pgml.load_dataset('bookcorpus', "limit" => 100); SELECT pgml.tune( diff --git a/pgml-cms/docs/use-cases/chatbots/README.md b/pgml-cms/docs/guides/chatbots/README.md similarity index 100% rename from pgml-cms/docs/use-cases/chatbots/README.md rename to pgml-cms/docs/guides/chatbots/README.md diff --git a/pgml-cms/docs/guides/embeddings/README.md b/pgml-cms/docs/guides/embeddings/README.md new file mode 100644 index 000000000..39557d79f --- /dev/null +++ b/pgml-cms/docs/guides/embeddings/README.md @@ -0,0 +1,86 @@ +--- +description: Embeddings are a key building block with many applications in modern AI/ML systems. They are particularly valuable for handling various types of unstructured data like text, images, and more, providing a pathway to richer insights and improved performance. A common use case for embeddings is to provide semantic search capabilities that go beyond traditional keyword matching to the underlying meaning in the data. +--- + +# Embeddings + +As the demand for sophisticated data analysis and machine learning capabilities within databases grows, so does the need for efficient and scalable solutions. PostgresML offers a powerful platform for integrating machine learning directly into PostgreSQL, enabling you to perform complex computations and predictive analytics without ever leaving your database. + +Embeddings are a key building block with many applications in modern AI/ML systems. They are particularly valuable for handling various types of unstructured data like text, images, and more, providing a pathway to richer insights and improved performance. They allow computers to operate on natural language and other high level concepts by reducing them to billions of simple arithmetic operations. + +## Applications of embeddings + +- **Search and Information Retrieval**: Embeddings can transform search queries and documents into vectors, making it easier to find the most relevant documents for a given query based on semantic similarity. +- **Personalization**: In recommendation systems, embeddings can help understand user queries and preferences, enhancing the accuracy of recommendations. +- **Text Generation**: Large language models use embeddings to generate coherent and contextually relevant text, which can be applied in scenarios ranging from chatbots to content creation. +- **Natural Language Understanding (NLU)**: Embeddings enable models to perform tasks such as sentiment analysis, named entity recognition, and summarization by understanding the context and meaning of texts. +- **Translation**: In machine translation, embeddings help models understand the semantic and syntactic structures of different languages, facilitating the translation process. + +This guide will introduce you to the fundamentals of embeddings within PostgresML. Whether you are looking to enhance text processing capabilities, improve image recognition functions, or simply incorporate more advanced machine learning models into your database, embeddings can play a pivotal role. By integrating these capabilities directly within PostgreSQL, you benefit from streamlined operations, reduced data movement, and the ability to leverage the full power of SQL alongside advanced machine learning techniques. + +In this guide, we will cover: + +* [In-database Generation](guides/embeddings/in-database-generation.md) +* [Dimensionality Reduction](guides/embeddings/dimensionality-reduction.md) +* [Aggregation](guides/embeddings/vector-aggregation.md) +* [Similarity](guides/embeddings/vector-similarity.md) +* [Normalization](guides/embeddings/vector-normalization.md) + + +## Embeddings are vectors + +In the context of large language models (LLMs), embeddings are representations of words, phrases, or even entire sentences. Each word or text snippet is mapped to a vector in a high-dimensional space. These vectors capture semantic and syntactic nuances, meaning that similar words have vectors that are close together in this space. For instance, "king" and "queen" would be represented by vectors that are closer together than "king" and "apple". + +Vectors can be stored in the native Postgres [`ARRAY[]`](https://www.postgresql.org/docs/current/arrays.html) datatype which is compatible with many application programming languages' native datatypes. Modern CPUs and GPUs offer hardware acceleration for common array operations, which can give substantial performance benefits when operating at scale, but which are typically not enabled in a Postgres database. You'll need to ensure you're compiling your full stack with support for your hardware to get the most bang for your buck, or you can leave that up to us, and get full hardware acceleration in a PostgresML cloud database. + +!!! warning + +Other cloud providers claim to offer embeddings "inside the database", but [benchmarks](../../resources/benchmarks/mindsdb-vs-postgresml.md) show that they are orders of magnitude slower than PostgresML. The reason is they don't actually run inside the database with hardware acceleration. They are thin wrapper functions that make network calls to remote service providers. PostgresML is the only cloud that puts GPU hardware in the database for full acceleration, and it shows. + +!!! + +## Vectors support arithmetic + +Vectors can be operated on mathematically with simple equations. For example, vector addition is defined as the sum of all the pairs of elements in the two vectors. This might be useful to combine two concepts into a single new embedding. For example "frozen" + "rain" should be similar to (≈) "snow" if the embedding model has encoded the nuances of natural language and precipitation. + +Most vector operations are simple enough to implement in a few lines of code. Here's a naive implementation (no hardware acceleration) of vector addition in some popular languages: + +{% tabs %} +{% tab title="JavaScript" %} + +```javascript +function add_vectors(x, y) { + let result = []; + for (let i = 0; i < x.length; i++) { + result[i] = x[i] + y[i]; + } + return result; +} + +let x = [1, 2, 3]; +let y = [1, 2, 3]; +add(x, y) +``` + +{% endtab %} + +{% tab title="Python" %} + +```python +def add_vectors(x, y): + return [x+y for x,y in zip(x,y)] + +x = [1, 2, 3] +y = [1, 2, 3] +add(x, y) +``` + +{% endtab %} +{% endtabs %} + + +If we pass the vectors for "snow" and "rain" into this function, we'd hope to get a vector similar to "snow" as the result, depending on the quality of the model that was used to create the word embeddings. diff --git a/pgml-cms/docs/guides/embeddings/dimensionality-reduction.md b/pgml-cms/docs/guides/embeddings/dimensionality-reduction.md new file mode 100644 index 000000000..ea829ed0b --- /dev/null +++ b/pgml-cms/docs/guides/embeddings/dimensionality-reduction.md @@ -0,0 +1,143 @@ +# Dimensionality Reduction + +In the case of embedding models trained on large bodies of text, most of the concepts they learn will be unused when dealing with any single piece of text. For collections of documents that deal with specific topics, only a fraction of the language models learned associations will be relevant. Dimensionality reduction is an important technique to improve performance _on your documents_, both in terms of quality and latency for embedding recall using nearest neighbor search. + +## Why Dimensionality Reduction? + +- **Improved Performance**: Reducing the number of dimensions can significantly improve the computational efficiency of machine learning algorithms. +- **Reduced Storage**: Lower-dimensional data requires less storage space. +- **Enhanced Visualization**: It is easier to visualize data in two or three dimensions. + +## What is Matrix Decomposition? +Dimensionality reduction is a key technique in machine learning and data analysis, particularly when dealing with high-dimensional data such as embeddings. A table full of embeddings can be considered a matrix, aka a 2-dimensional array with rows and columns, where the embedding dimensions are the columns. We can use matrix decomposition methods, such as Principal Component Analysis (PCA) and Singular Value Decomposition (SVD), to reduce the dimensionality of embeddings. + +Matrix decomposition involves breaking down a matrix into simpler, constituent matrices. The most common decomposition techniques for this purpose are: + +- **Principal Component Analysis (PCA)**: Reduces dimensionality by projecting data onto a lower-dimensional subspace that captures the most variance. +- **Singular Value Decomposition (SVD)**: Factorizes a matrix into three matrices, capturing the essential features in a reduced form. + +## Dimensionality Reduction with PostgresML +PostgresML allows in-database execution of matrix decomposition techniques, enabling efficient dimensionality reduction directly within the database environment. + +## Step-by-Step Guide to Using Matrix Decomposition + +### Preparing the data +We'll create a set of embeddings using modern embedding model with 384 dimensions. + +```postgresql +CREATE TABLE documents_with_embeddings ( +id SERIAL PRIMARY KEY, +body TEXT, +embedding FLOAT[] GENERATED ALWAYS AS (pgml.normalize_l2(pgml.embed('intfloat/e5-small-v2', body))) STORED +); +``` + +!!! generic + +!!! code_block time="46.823" + +```postgresql +INSERT INTO documents_with_embeddings (body) +VALUES -- embedding vectors are automatically generated + ('Example text data'), + ('Another example document'), + ('Some other thing'), + ('We need a few more documents'), + ('At least as many documents as dimensions in the reduction'), + ('Which normally isn''t a problem'), + ('Unless you''re typing out a bunch of demo data'); +``` + +!!! + +!!! results + +```postgresql +INSERT 0 3 +``` + +!!! + +!!! + + +!!! generic + +!!! code_block time="14.259ms" + +```postgresql +CREATE VIEW just_embeddings AS +SELECT embedding +FROM documents_with_embeddings; +``` + +!!! + +!!! results + +```postgresql + CREATE VIEW +``` + +!!! + +!!! + +### Decomposition + +Models can be trained using `pgml.train` on unlabeled data to identify important features within the data. To decompose a dataset into it's principal components, we can use the table or a view. Since decomposition is an unsupervised algorithm, we don't need a column that represents a label as one of the inputs to `pgml.train`. + +Train a simple model to find reduce dimensions for 384, to the 3: + +!!! generic + +!!! code_block time="48.087 ms" + +```postgresql +SELECT * FROM pgml.train('Embedding Components', 'decomposition', 'just_embeddings', hyperparams => '{"n_components": 3}'); +``` + +!!! + +!!! results + +```postgresql +INFO: Metrics: {"cumulative_explained_variance": 0.69496775, "fit_time": 0.008234134, "score_time": 0.001717504} +INFO: Deploying model id: 2 + + project | task | algorithm | deployed +----------------------+---------------+-----------+---------- + Embedding Components | decomposition | pca | t +``` + +!!! + +!!! + +Note that the input vectors have been reduced from 384 dimensions to 3 that explain 69% of the variance across all samples. That's a more than 100x size reduction, while preserving 69% of the information. These 3 dimensions may be plenty for a course grained first pass ranking with a vector database distance function, like cosine similarity. You can then choose to use the full embeddings, or some other reduction, or the raw text with a reranker model to improve final relevance over the baseline with all the extra time you have now that you've reduced the cost of initial nearest neighbor recall 100x. + +You can check out the components for any vector in this space using the reduction model: + +!!! generic + +!!! code_block time="14.259ms" + +```postgresql +SELECT pgml.decompose('Embedding Components', embedding) AS pca +FROM just_embeddings +LIMIT 10; +``` + +!!! + +!!! results + +```postgresql + CREATE VIEW +``` + +!!! + +!!! + +Exercise for the reader: Where is the sweet spot for number of dimensions, yet preserving say, 99% of the relevance data? How much of the cumulative explained variance do you need to preserve 100% to return the top N results for the reranker, if you feed the reranker top K using cosine similarity or another vector distance function? diff --git a/pgml-cms/docs/guides/embeddings/in-database-generation.md b/pgml-cms/docs/guides/embeddings/in-database-generation.md new file mode 100644 index 000000000..f4e23f174 --- /dev/null +++ b/pgml-cms/docs/guides/embeddings/in-database-generation.md @@ -0,0 +1,222 @@ +# In-database Embedding Generation + +Embedding generation is a process of transforming high-dimensional data into dense vectors of fixed size, which can be used for various machine learning tasks. PostgresML makes it easy to generate embeddings from text in your database using state-of-the-art models with the native function **`pgml.embed`**`(model_name, text)`, leveraging the computational power of local GPUs. + +## Introduction + +Different models have been trained on different types of text and with different algorithms. Each one has its own tradeoffs, generally latency vs quality, although recent progress in the LLMs. + +## Benefits of in-database processing +PostgresML cloud databases include GPU hardware to run state-of-the-art models for embedding generation within the database environment, among other ML/AI workloads. This contrasts with network calls, where data must be sent to an external service for processing. If you're running PostgresML on your own hardware it's important to configure it correctly, or choose an embedding model that will run efficiently on a CPU. + +- **Reduced Latency**: Local computation eliminates the need for network calls, significantly reducing latency. +- **Enhanced Security**: Data remains within the database, enhancing security by minimizing exposure. +- **Cost-Effectiveness**: Utilizing local hardware can be more cost-effective than relying on external services, especially for large-scale operations. + +GPU accelerated models can compute embeddings in sub millisecond timeframes when batching, this means that even _in-datacenter_ processing is orders of magnitude more expensive than _in-database_, in terms of latency and finances due to the networking overhead. Using a hosted service to generate embeddings outside-of your datacenter, is even less efficient, given the additional overhead of transport costs. + +## Model Selection + +There are many excellent pre-trained open-weight models available for download from HuggingFace. PostgresML serverless instances run with the following models available w/ instant autoscaling: + +| Model | Parameters (M) | Strengths | +|-------------------------------------------------------------------------------------------------|----------------|--------------------------------| +| [intfloat/e5-small-v2](https://huggingface.co/intfloat/e5-small-v2) | 33.4 | High quality, lowest latency | +| [mixedbread-ai/mxbai-embed-large-v1](https://huggingface.co/mixedbread-ai/mxbai-embed-large-v1) | 335 | Higher quality, higher latency | +| [Alibaba-NLP/gte-large-en-v1.5](https://huggingface.co/Alibaba-NLP/gte-large-en-v1.5) | 434 | Supports up to 8k token inputs | + + +If you'd like to use a different model you can also provision dedicated resources for it. The [Massive Text Embedding Benchmark](https://huggingface.co/spaces/mteb/leaderboard) is a helpful resource provided by HuggingFace that maintains up-to-date rankings on the latest models. + +## Creating Embeddings + +You can generate embeddings using [pgml.embed(model_name, text)](../../api/sql-extension/pgml.embed.md). For example: + +!!! generic + +!!! code_block time="12.029 ms" + +```postgresql +SELECT pgml.embed('intfloat/e5-small-v2', 'This is some text to embed'); +``` + +!!! + +!!! results + +```postgresql +{-0.080910146,0.033980247,0.052564066,0.0020346553,-0.03936229,0.031479727,0.0685036,-0.06294509,-0.024574954,0.040237393,0.051508162,0.0038814095,-0.010645757,0.020144403,0.031223888,-0.04440482,0.020333821,0.07103317,-0.12705344,0.030591827,0.07019173,-0.036886554,-0.012233759,-0.07092232,0.0027690812,-0.0020539823,0.040779375,0.05908495,-0.026025668,-0.08242788,-0.018558107,-0.0094666025,0.059807047,-0.02525427,0.103207916,-0.068966456,-0.039847758,0.04071019,0.04450286,0.03424993,-0.06227554,-0.055733517,0.054585237,-0.060373828,-0.024653753,0.009867895,-0.041141387,-0.08721736,0.08264962,-0.0031608255,-0.012134463,-0.014921003,0.04267465,0.029093502,0.058714338,0.023871746,0.027041607,0.05843493,0.04142925,0.09514731,-0.030493727,0.07500542,-0.11280806,0.10281551,0.055736117,0.061823647,-0.020118464,0.014440284,-0.08269981,0.0040008957,-0.018531831,-0.008568512,-0.046970874,0.04578424,-0.039577056,0.08775033,-0.008210567,0.051924113,-0.04171466,-0.0367731,-0.01827072,0.0069318637,-0.047051124,0.033687923,0.0075546373,-0.037275027,0.043123465,-0.045893792,-0.036658753,-0.040635854,-0.03440536,0.0011549098,0.042740136,-0.025120102,-0.017873302,-0.039899718,0.031648446,0.0068402113,0.02402832,0.089285314,0.017456057,0.012008715,0.0076218387,-0.07197755,-0.038144454,-0.05969434,0.0389503,-0.0058245854,0.01937407,-0.018212182,-0.06195428,-0.038283527,-0.01753182,-0.023789542,0.07097847,0.04855445,-0.05200343,-0.009433737,-0.010195946,0.00442146,0.043388885,-0.013206756,0.03384104,0.0052567925,0.10585855,-0.08633147,0.05733634,0.046828035,0.111744046,-0.016215837,0.031619936,-0.0007159129,-0.0209652,-0.015532438,-0.06690792,-0.0091873575,-0.044681326,-0.007757966,0.053561073,-0.011261849,-0.03140146,-0.050118096,-0.031356297,-0.124189764,0.024152948,0.02993825,-0.07240996,0.01793813,-0.070896275,-0.024419364,-0.040071633,-0.026535412,0.027830372,0.021783136,-0.0075028464,0.014013486,-0.005176842,0.044899847,-0.068266265,-0.024272943,-0.104513876,-0.007814491,0.06390731,0.10318874,0.08249727,-0.092428714,0.0062611965,-0.0115522025,0.056004044,-0.043695573,-0.0010207174,0.013102924,-0.0035022667,0.0025919478,0.12973104,-0.053112745,-0.008374208,-0.022599943,0.04597443,-0.074845895,0.07259128,-0.062168732,-0.03033916,0.03646452,0.033044446,-0.040221635,-0.060735658,-0.040255345,0.013989559,-0.026528435,-0.059659433,-0.0010745272,-0.02860176,0.073617734,0.009127505,0.012357427,-0.024373775,-0.07039051,-0.038225688,-0.07232986,0.06928063,0.06729482,-0.07500053,0.0036577163,-0.03904865,0.09585222,0.035453793,-0.0061846063,-0.05000263,-0.050227694,-0.022932036,-0.0073578595,-0.034768302,-0.038604897,-0.01470962,-0.04274356,-0.01689811,0.04931222,0.010990732,0.019879386,0.01243605,-0.07632878,-0.070137314,-0.15282577,-0.020428825,-0.030160243,-0.0050396603,0.007732285,-0.032149784,-0.015778365,0.07480648,0.017192233,0.024550207,0.06951421,-0.014848112,-0.05396024,-0.03223639,0.04666939,0.012844642,-0.05892448,-0.030294335,0.06794056,-0.063875966,-0.046530016,-0.07084713,-0.031829637,-0.047059055,0.08617301,-0.05032479,0.118310556,0.04755146,-0.028393123,-0.024320556,0.030537084,0.020449162,0.05665035,-0.075432904,0.07822404,-0.07196871,0.010495469,0.05382172,-0.0016319404,-0.087258086,0.0930253,-0.01846083,0.0033103244,-0.08890738,0.071200974,-0.03997286,-0.005042026,0.011910354,-0.025650134,0.054577664,-0.0014927471,-0.047521923,0.049124297,0.006342861,-0.089150384,-0.0073342607,-0.07849969,0.0010329112,-0.038727123,0.016429648,-0.086470395,-4.8742084e-05,0.060051307,0.0033317064,0.006863758,0.0446841,-0.031092882,0.017449407,-0.07479843,-0.058406148,-0.012044445,0.08927765,-0.04008159,0.05227031,0.021864118,0.054245688,0.027357962,0.02569578,-0.06151034,-0.05588746,-0.034790445,-0.020313034,0.03713666,0.025836824,0.039398894,0.02515884,-0.008512022,-0.014856683,0.037740804,-0.06471344,0.029907772,0.0077477624,0.061302595,0.037709966,-0.032406874,-0.049870085,-0.15800017,-0.014624413,0.018514019,-0.010369406,-0.022790398,0.009587365,0.03241724,-0.02795245,-0.05280684,-0.031362813,0.047515675,0.009669598,0.09689132,-0.038499177,-0.019239947,0.06885492,0.08843166,-0.027636368,-0.058589518,-0.11492329,0.036349587,0.03926196,0.16907486,0.036197387,-0.0128475325,0.05160944,0.0034505632,0.016367715,0.068978526,0.0676247,0.0064224014,-0.06316567,0.11720159,0.005348484,0.05403974,0.061581556,-0.027833184,0.05563025,0.03337182,-0.030032963,0.06838953,0.08052612,-0.01996433,0.006692282,0.11277913,0.03004468,-0.063005574,-0.024108425,-0.03547973,0.0060482216,-0.0032331524,-0.038302638,0.083412275,0.07387719,0.052097928,-0.037775334,-0.05458932,0.0004270608,-0.034030076,-0.07965879,0.012511749,-0.028165875,0.03768439,0.00082042674,0.053660177} +``` + +!!! + +!!! + +A database typically holds the text data used to generate the embeddings in a table. We'll use `documents` as an example. + +```postgresql +CREATE TABLE documents ( + id SERIAL PRIMARY KEY, + body TEXT +); +``` + +Inserting some example data: + +```postgresql +INSERT INTO documents (body) +VALUES + ('Example text data'), + ('Another example document'), + ('Some other thing'); +``` + +Passing the data from the table to the embedding function: + +!!! generic + +!!! code_block time="50.001 ms" + +```postgresql +SELECT id, pgml.embed('intfloat/e5-small-v2', body) +FROM documents; +``` + +!!! + +!!! results + +```postgresql + id | embed +---+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1 | {-0.09234577,0.037487056,-0.03421769,-0.033738457,-0.042548284,-0.0015319627,0.042109113,0.011365055,-0.018372666,0.020417988,0.061961487,-0.022707041,0.015810987,0.03675479,0.001995532,-0.04197657,-0.034883354,0.07871886,-0.11676137,0.06141681,0.08321331,-0.03457781,-0.013248807,-0.05802344,-0.039144825,-0.015038275,0.020686107,0.08593334,-0.041029375,-0.13210341,-0.034079146,0.016687978,0.06363906,-0.05279167,0.10102262,-0.048170853,-0.014849669,0.03523273,0.024248678,0.031341534,-0.021447029,-0.05781338,0.039722513,-0.058294114,-0.035174508,-0.056844078,-0.051775914,-0.05822031,0.083022244,0.027178412,0.0032413877,0.023898097,0.023951318,0.0565093,0.036267336,0.049430914,0.027110789,0.05017207,0.058326595,0.040568575,0.014855128,0.06272174,-0.12961388,0.0998898,0.014964503,0.07735804,-0.028795758,0.026889611,-0.0613238,-0.004798127,0.009027658,0.046634953,-0.034936648,0.076499216,-0.03855506,0.08894715,-0.0019889707,0.07027481,-0.04624302,-0.048422314,-0.02444203,-0.0442959,-0.028878363,0.04586853,-0.004158767,-0.0027680802,0.029728336,-0.06130052,-0.028088963,-0.050658133,-0.024370935,-0.0030779864,0.018137587,-0.029853988,-0.06877675,-0.001238518,0.025249483,-0.0045243553,0.07250941,0.12831028,0.0077543575,0.012130527,-0.0006014347,-0.027807593,-0.011226617,-0.04837827,0.0376276,-0.058811083,0.020967057,-0.021439878,-0.0634577,-0.029189702,-0.040197153,-0.01993339,0.0899751,-0.014370172,0.0021994617,-0.0759979,-0.010541287,0.034424484,0.030067233,0.016858222,0.015223163,0.021410512,0.072372325,-0.06270684,0.09666927,0.07237114,0.09372637,-0.027058149,0.06319879,-0.03626834,-0.03539027,0.010406426,-0.08829164,-0.020550422,-0.043701466,-0.018676292,0.038060706,-0.0058152666,-0.04057362,-0.06266247,-0.026675962,-0.07610313,-0.023740835,0.06968648,-0.076157875,0.05129882,-0.053703927,-0.04906172,-0.014506706,-0.033226766,0.04197027,0.009892002,-0.019509513,0.020975547,0.015931072,0.044290986,-0.048697367,-0.022310019,-0.088599496,-0.0371257,0.037382104,0.14381507,0.07789086,-0.10580675,0.0255245,0.014246269,0.01157928,-0.069586724,0.023313843,0.02494169,-0.014511085,-0.017566541,0.0865948,-0.012115137,0.024397936,-0.049067125,0.03300015,-0.058626212,0.034921415,-0.04132337,-0.025009211,0.057668354,0.016189015,-0.04954466,-0.036778226,-0.046015732,-0.041587763,-0.03449501,-0.033505566,0.019262834,-0.018552447,0.019556912,0.01612039,0.0026575527,-0.05330489,-0.06894643,-0.04592849,-0.08485257,0.12714563,0.026810834,-0.053618323,-0.029470881,-0.04381535,0.055211045,-0.0111715235,-0.004484313,-0.02654065,-0.022317547,-0.027823675,0.0135190515,0.001530742,-0.04323672,-0.028350104,-0.07154715,-0.0024147208,0.031836234,0.03476004,0.033611998,0.038179073,-0.087631755,-0.048408568,-0.11773682,-0.019127818,0.013682835,-0.02015055,0.01888005,-0.03280704,0.0076310635,0.074330166,-0.031277154,0.056628436,0.119448215,-0.0012235055,-0.009727585,-0.05459528,0.04298459,0.054554865,-0.027898816,0.0040641865,0.08585007,-0.053415824,-0.030528797,-0.08231634,-0.069264784,-0.08337459,0.049254872,-0.021684796,0.12479715,0.053940497,-0.038884085,-0.032209005,0.035795107,0.0054665194,0.0085438965,-0.039386917,0.083624765,-0.056901276,0.022051739,0.06955752,-0.0008329906,-0.07959222,0.075660035,-0.017008293,0.015329365,-0.07439257,0.057193674,-0.06564091,0.0007063081,-0.015799401,-0.008529507,0.027204275,0.0076780985,-0.018589584,0.065267086,-0.02026929,-0.0559547,-0.035843417,-0.07237942,0.028072618,-0.048903402,-0.027478782,-0.084877744,-0.040812787,0.026713751,0.016210195,-0.039116003,0.03572044,-0.014964189,0.026315138,-0.08638934,-0.04198059,-0.02164005,0.09299754,-0.047685668,0.061317034,0.035914674,0.03533252,0.0287274,-0.033809293,-0.046841178,-0.042211317,-0.02567011,-0.048029255,0.039492987,0.04906847,0.030969618,0.0066106897,0.025528666,-0.008357054,0.04791732,-0.070402496,0.053391967,-0.06309544,0.06575766,0.06522203,0.060434356,-0.047547556,-0.13597175,-0.048658505,0.009734684,-0.016258504,-0.034227647,0.05382081,0.001330341,0.011890187,-0.047945525,-0.031132223,0.0010349775,0.030007072,0.12059559,-0.060273632,-0.010099646,0.055261053,0.053757478,-0.045518342,-0.041972063,-0.08315036,0.049884394,0.037543204,0.17598632,-0.0027433096,0.015989233,0.017486975,0.0059954696,-0.022668751,0.05677827,0.029728843,0.0011321013,-0.051546678,0.1113402,0.017779723,0.050953783,0.10342974,0.04067395,0.054890294,0.017487328,-0.020321153,0.062171113,0.07234749,-0.06777497,-0.03888628,0.08744684,0.032227095,-0.04398878,-0.049698275,-0.0018518695,-0.015967874,-0.0415869,-0.022655524,0.03596353,0.07130526,0.056296617,-0.06720573,-0.092787154,0.021057911,0.015628621,-0.04396636,-0.0063872878,-0.0127499355,0.01633339,-0.0006204544,0.0438727} + 2 | {-0.11384405,0.067140445,0.004428383,-0.019213142,0.011713443,0.009808596,0.06439777,-0.014959955,-0.03600561,0.01949383,0.04094742,0.030407589,-0.026018979,0.044171993,0.022412317,-0.057937913,-0.05182386,0.07793179,-0.109105654,0.057499174,0.102279164,-0.04705679,0.0010215766,-0.052305017,-0.0064890077,-0.019298203,0.0027092565,0.07363092,-0.010116459,-0.12196041,-0.025577176,0.010314696,0.031369787,-0.020949671,0.08722754,-0.051809352,0.0007810379,0.07672705,-0.008455481,0.06511949,-0.021327827,-0.060510863,0.044916406,-0.08674781,-0.047401372,-0.01868107,-0.075262256,-0.055392392,0.072947465,-0.01151735,-0.0072187134,0.015544381,0.039965566,0.020232335,0.04894269,0.04900096,0.05358905,0.032501124,0.053288646,0.07584814,0.031957388,0.05976136,-0.12726106,0.103460334,0.06346268,0.06554993,-0.045167506,0.012330433,-0.062929176,0.043507233,-0.008544882,0.027812833,-0.040016085,0.055822216,-0.03835489,0.040096387,0.018063055,0.060356017,-0.0726533,-0.0671456,-0.05047295,-0.042710193,-0.042777598,-0.006822609,0.012524907,-0.032105528,0.026691807,-0.05756205,0.015424967,-0.04767447,-0.036748573,-0.02527533,0.025934244,-0.033328723,-4.1858173e-05,-0.027706677,0.047805857,0.00018475522,0.050902035,0.1352519,0.005388455,0.029921843,-0.02537518,-0.058101207,-0.021984883,-0.059336115,0.03498545,-0.052446626,0.022411253,0.0060822135,-0.068493545,-0.013820616,-0.03522277,-0.018971028,0.07487064,-0.0009035772,-0.009381329,-0.04850395,0.001105027,0.016467793,0.0268643,0.0013964645,0.043346133,-0.009041368,0.07489963,-0.07887815,0.068340026,0.03767777,0.11665796,-0.025433592,0.062018104,-0.030672694,-0.012993033,0.0068405713,-0.03688894,-0.022034604,-0.040981747,-0.033101898,0.071058825,-0.0017327801,-0.021141728,-0.07144207,-0.02906128,-0.095396295,0.006055787,0.08500532,-0.031142898,0.055712428,-0.041926548,-0.042101618,-0.013311086,-0.046836447,0.023902802,0.031264246,-0.012085872,0.042904463,0.011645057,0.049069524,-0.0039288886,-0.014362478,-0.06809574,-0.038734697,0.028410498,0.12843607,0.090781115,-0.119838186,0.016676102,0.0009924435,0.0314442,-0.040607806,0.0020882064,0.044765383,0.01829387,-0.05677682,0.08415222,-0.06399008,-0.010945022,-0.024140757,0.046428833,-0.0651499,0.041250102,-0.06294866,-0.032783676,0.047456875,0.034612734,-0.021892011,-0.050926965,-0.06388983,-0.031164767,0.053277884,-0.069394015,0.03465082,-0.0410735,0.03736871,0.010950864,0.01830701,-0.070063934,-0.06988279,-0.03560967,-0.05519299,0.07882521,0.05533408,-0.02321644,0.007326457,-0.05126765,0.045479607,0.01830127,-0.037239183,-0.08015762,-0.056017533,-0.07647084,-0.0065865014,-0.027235825,-0.039984804,-0.0156225115,-0.014561295,0.024489071,0.009097713,0.04265267,-0.003169223,0.010329996,-0.078917705,-0.026417341,-0.13925064,-0.009786513,-0.037679326,-0.023494951,0.016230932,-0.010068113,0.008919443,0.05672694,-0.0647096,0.0074613485,0.0856074,-0.0072963624,-0.04508945,-0.027654354,0.031864826,0.046863783,-0.032239847,-0.024967564,0.065593235,-0.05142123,-0.011477745,-0.083396286,-0.036403924,-0.030264381,0.060208946,-0.037968345,0.13118903,0.055968005,-0.02204113,-0.00871512,0.06265703,0.024767108,0.06307163,-0.093918525,0.06388834,-0.027308429,0.028177679,0.046643235,-0.008643308,-0.08599351,0.08742052,-0.0045658057,0.009925819,-0.061982065,0.06666853,-0.085638665,-0.008682048,0.016528588,-0.015443429,0.040419903,0.0059123226,-0.04848474,0.026133329,-0.042095724,-0.06860905,-0.033551272,-0.06492134,0.019667841,-0.04917464,-0.0096588,-0.10072659,-0.07769663,0.03221359,0.019174514,0.039727442,0.025392585,-0.016384942,0.0024048705,-0.09175566,-0.03225071,0.0066428655,0.10759633,-0.04011207,0.031578932,0.06299788,0.061487168,0.048043367,-0.0047893273,-0.054848563,-0.06647676,-0.027905045,-0.055799212,0.028914401,0.04013868,0.050728165,-0.0063177645,-0.018899892,0.008193828,0.025991635,-0.08009935,0.044058595,-0.046858713,0.072079815,0.046664152,0.019002488,-0.018447064,-0.15560018,-0.050175466,0.001016439,-0.0035773942,-0.025972001,0.047064543,0.01866733,0.0049167247,-0.052880444,-0.029235922,-0.024581103,0.040634423,0.095990844,-0.019483034,-0.02325509,0.056078408,0.09241045,-0.03079215,-0.023518562,-0.08394134,0.03326668,0.008070111,0.14776507,0.030338759,-0.01846056,0.009517991,0.0034727904,0.007246884,0.015436005,0.058226254,-0.037932027,-0.04309255,0.09766471,0.014914252,0.03149386,0.10146584,0.009303289,0.05649276,0.04743103,-0.016993523,0.054828145,0.033858124,-0.059207607,-0.027288152,0.09254907,0.07817234,-0.047911037,-0.023988279,-0.067968085,-0.03140125,-0.02434741,-0.017226815,0.050405838,0.048384074,0.10386314,-0.05366119,-0.048218876,0.022471255,-0.04470827,-0.055776954,0.0146418335,-0.03505756,0.041757654,0.0076765255,0.0637766} + 3 | {-0.06530473,0.043326367,0.027487691,-0.012605501,-0.003679171,0.0068843057,0.093755856,-0.018192727,-0.038994554,0.060702052,0.047350235,0.0015797003,-0.026038624,0.029946782,0.053223953,-0.009188536,-0.012273773,0.07512682,-0.1220027,0.024623549,0.040207546,-0.061494265,-0.0016338134,-0.096063755,-0.020626824,-0.0008177105,0.025736991,0.08205663,-0.064413406,-0.10329614,-0.050153203,0.022038238,-0.011629073,-0.03142779,0.09684598,-0.045188677,-0.032773193,0.041901052,0.032470446,0.06218501,0.00056252955,-0.03571358,0.030095506,-0.09239761,-0.020187493,-0.00932361,-0.08373726,-0.053929392,0.09724756,-0.032078817,0.02658544,0.009965162,0.07477913,0.05487153,0.023828406,0.06263976,0.06882497,0.08249143,0.062069558,0.08915651,-0.005154778,0.056259956,-0.13729677,0.08404741,0.07149277,0.04482675,-0.058625933,0.0034976404,-0.030747578,0.004520399,0.0007449915,9.660358e-05,-0.022526976,0.11449101,-0.043607008,0.026769284,0.021050733,0.05854427,-0.042627476,-0.022924222,-0.059794623,-0.037738875,-0.018500011,0.017315088,-0.00020744087,-0.0016206327,0.013337528,-0.022439854,-0.0042932644,-0.04706647,-0.06771751,-0.040391076,0.0638978,-0.031776994,0.011536817,-0.04593729,0.08626801,0.0016808647,-0.0046028513,0.13702579,0.02293593,0.043189116,-0.0073873955,-0.06097065,-0.019305069,-0.025651531,0.043129053,-0.033460874,0.03261353,-0.022361644,-0.07769732,-0.021210406,-0.020294553,-0.044899672,0.083500296,0.038056396,-0.052046232,-0.03215008,-0.028185,0.041909587,0.016012225,-0.0058236965,0.021344814,-0.037620485,0.07454872,-0.03517924,0.086520284,0.096695796,0.0937938,-0.04190071,0.072271764,-0.07022541,0.01583733,-0.0017275782,-0.05280332,-0.005904967,-0.046241984,-0.024421731,0.09988276,-0.0077029592,-0.04107849,-0.091607556,0.033811443,-0.1323201,-0.015927043,0.011014193,-0.039773338,0.033963792,-0.053305525,-0.005038948,-0.024107914,-0.0079898145,0.039604105,0.009226985,0.0010978039,-0.015565131,-0.0002796709,0.037623808,-0.059376597,0.015390821,-0.07600872,-0.008280972,0.023050148,0.0777234,0.061332665,-0.13979945,-0.009342198,0.012803744,0.049805813,-0.03578894,-0.05038778,0.048912454,0.032017626,0.015345221,0.10369494,-0.048897773,-0.054201737,-0.015793057,0.08130064,-0.064783126,0.074246705,-0.06964914,-0.025839275,0.030869238,0.06357789,-0.028754702,-0.02960897,-0.04956488,0.030501548,0.005857936,-0.023547728,0.03717584,0.0024309678,0.066338174,-0.009775384,-0.030799516,-0.028462514,-0.058787093,-0.051071096,-0.048674088,0.011397957,0.07817651,-0.03227047,0.027149512,-0.0030777291,0.061677814,0.0025318298,-0.027110869,-0.0691719,-0.033963803,-0.0648151,-0.033951994,-0.0478505,0.0016642202,-0.019602248,-0.030472266,0.015889537,-0.0009066139,0.032841947,0.021004336,-0.029254122,-0.09597239,-0.04359093,-0.15422617,-0.016366383,-0.059343938,-0.064871244,0.07659653,0.023196936,-0.021893008,0.080793895,-0.05248758,0.018764181,0.0008353451,-0.03318359,-0.04830206,-0.05518034,0.038481984,0.06544077,0.019498836,-0.054670736,0.040052623,-0.028875519,-0.047129385,-0.03614192,-0.012638911,-0.0042204396,0.013685266,-0.047130045,0.11024768,0.07135732,-0.017937008,-0.040911496,0.09008783,0.039298594,0.042975742,-0.08974752,0.08711358,-0.021977019,0.051495675,0.0140351625,-0.053809136,-0.08241595,0.04982693,-0.020355707,0.017629888,-0.039196398,0.08688628,-0.051167585,-0.029257154,0.009161573,-0.0021740724,0.027258197,0.015352816,-0.07426982,0.022452697,-0.041628033,-0.023250584,-0.051996145,-0.031867135,-0.01930267,-0.05257186,0.032619886,-0.08220233,-0.017010445,0.038414452,-0.02268424,0.007727591,0.0064041745,-0.024256933,0.0028989788,-0.06191567,-0.020444075,-0.010515549,0.08980986,-0.020033991,0.009208651,0.044014987,0.067944355,0.07915397,0.019362122,-0.010731527,-0.057449125,-0.007854527,-0.067998596,0.036500365,0.037355963,-0.0011789168,0.030410502,-0.012768641,-0.03281059,0.026916556,-0.052477527,0.042145997,-0.023683913,0.099338256,0.035008017,-0.029086927,-0.032222193,-0.14743629,-0.04350868,0.030494612,-0.013000542,0.021753347,0.023393912,0.021320568,0.0031570331,-0.06008047,-0.031103736,0.030275675,0.015258714,0.09004704,0.0033432578,-0.0045539658,0.06602429,0.072156474,-0.0613405,-0.047462273,-0.057639644,-0.008026253,0.03090332,0.12396069,0.04592149,-0.053269017,0.034282286,-0.0045666047,-0.026025562,0.004598449,0.04304216,-0.02252559,-0.040372007,0.08094969,-0.021883471,0.05903653,0.10130699,0.001840184,0.06142003,0.004450253,-0.023686321,0.014760433,0.07669066,-0.08392746,-0.028447477,0.08995419,0.028487092,-0.047503598,-0.026627144,-0.0475691,-0.069141485,-0.039571274,-0.054866526,0.04417342,0.08155949,0.065555565,-0.053984754,-0.04142323,-0.023902748,0.0066344747,-0.065118864,0.02183451,-0.06479133,0.010425607,-0.010283142,0.0940532} +``` + +!!! + +!!! + +We can store embeddings in the database as well. Here's an example of creating a temporary table to hold all the embeddings during the current transaction. + +!!! generic + +!!! code_block time="54.123 ms" + +```postgresql +CREATE TEMPORARY TABLE embeddings AS +SELECT id AS document_id, + pgml.embed('intfloat/e5-small-v2', body) +FROM documents; +``` + +!!! + +!!! results + +```postgresql +SELECT 3 +``` + +!!! + +!!! + +Another way would be to generated and store the embeddings any time a document is updated: + +```postgresql +CREATE TABLE documents_with_embeddings ( +id SERIAL PRIMARY KEY, +body TEXT, +embedding FLOAT[] GENERATED ALWAYS AS (pgml.normalize_l2(pgml.embed('intfloat/e5-small-v2', body))) STORED +); +``` + +!!! generic + +!!! code_block time="46.823" + +```postgresql +INSERT INTO documents_with_embeddings (body) +VALUES -- embedding vectors are automatically generated + ('Example text data'), + ('Another example document'), + ('Some other thing'); +``` + +!!! + +!!! results + +```postgresql +INSERT 0 3 +``` + +!!! + +!!! + +You could also use a Common Table Expression to generate an embedding on the fly and then reference it later in the SQL statement. For example, to generate a search embedding, and compare it to all existing embeddings in a table to find the nearest neighbors: + +!!! generic + +!!! code_block time="25.688 ms" +```postgresql +WITH query AS ( + SELECT pgml.embed('intfloat/e5-small-v2', 'An example search query') AS embedding +) +SELECT id, pgml.distance_l2(query.embedding, documents_with_embeddings.embedding) +FROM documents_with_embeddings, query +ORDER BY distance_l2; +``` + +!!! results + +```postgresql + id | distance_l2 +----+--------------------- + 1 | 0.45335962377530326 + 2 | 0.49441662560530825 + 3 | 0.632445005046323 +``` + +!!! + +!!! + +## Batching + +PostgresML supports batching embeddings. It turns out, a lot of the cost of generating an embedding is streaming the model weights for each layer from memory to the processors, rather than performing the actual calculations. By batching embeddings, we can reuse the weights for each layer on multiple inputs, before loading the next layer and continuing, which amortizes the RAM latency across all embeddings. + +!!! generic + +!!! code_block time="21.204 ms" + +```postgresql +SELECT pgml.embed('intfloat/e5-small-v2', array_agg(body)) AS embedding +FROM documents; +``` + +!!! + +!!! results + +```postgresql + id | embed +---+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1 | {-0.09234577,0.037487056,-0.03421769,-0.033738457,-0.042548284,-0.0015319627,0.042109113,0.011365055,-0.018372666,0.020417988,0.061961487,-0.022707041,0.015810987,0.03675479,0.001995532,-0.04197657,-0.034883354,0.07871886,-0.11676137,0.06141681,0.08321331,-0.03457781,-0.013248807,-0.05802344,-0.039144825,-0.015038275,0.020686107,0.08593334,-0.041029375,-0.13210341,-0.034079146,0.016687978,0.06363906,-0.05279167,0.10102262,-0.048170853,-0.014849669,0.03523273,0.024248678,0.031341534,-0.021447029,-0.05781338,0.039722513,-0.058294114,-0.035174508,-0.056844078,-0.051775914,-0.05822031,0.083022244,0.027178412,0.0032413877,0.023898097,0.023951318,0.0565093,0.036267336,0.049430914,0.027110789,0.05017207,0.058326595,0.040568575,0.014855128,0.06272174,-0.12961388,0.0998898,0.014964503,0.07735804,-0.028795758,0.026889611,-0.0613238,-0.004798127,0.009027658,0.046634953,-0.034936648,0.076499216,-0.03855506,0.08894715,-0.0019889707,0.07027481,-0.04624302,-0.048422314,-0.02444203,-0.0442959,-0.028878363,0.04586853,-0.004158767,-0.0027680802,0.029728336,-0.06130052,-0.028088963,-0.050658133,-0.024370935,-0.0030779864,0.018137587,-0.029853988,-0.06877675,-0.001238518,0.025249483,-0.0045243553,0.07250941,0.12831028,0.0077543575,0.012130527,-0.0006014347,-0.027807593,-0.011226617,-0.04837827,0.0376276,-0.058811083,0.020967057,-0.021439878,-0.0634577,-0.029189702,-0.040197153,-0.01993339,0.0899751,-0.014370172,0.0021994617,-0.0759979,-0.010541287,0.034424484,0.030067233,0.016858222,0.015223163,0.021410512,0.072372325,-0.06270684,0.09666927,0.07237114,0.09372637,-0.027058149,0.06319879,-0.03626834,-0.03539027,0.010406426,-0.08829164,-0.020550422,-0.043701466,-0.018676292,0.038060706,-0.0058152666,-0.04057362,-0.06266247,-0.026675962,-0.07610313,-0.023740835,0.06968648,-0.076157875,0.05129882,-0.053703927,-0.04906172,-0.014506706,-0.033226766,0.04197027,0.009892002,-0.019509513,0.020975547,0.015931072,0.044290986,-0.048697367,-0.022310019,-0.088599496,-0.0371257,0.037382104,0.14381507,0.07789086,-0.10580675,0.0255245,0.014246269,0.01157928,-0.069586724,0.023313843,0.02494169,-0.014511085,-0.017566541,0.0865948,-0.012115137,0.024397936,-0.049067125,0.03300015,-0.058626212,0.034921415,-0.04132337,-0.025009211,0.057668354,0.016189015,-0.04954466,-0.036778226,-0.046015732,-0.041587763,-0.03449501,-0.033505566,0.019262834,-0.018552447,0.019556912,0.01612039,0.0026575527,-0.05330489,-0.06894643,-0.04592849,-0.08485257,0.12714563,0.026810834,-0.053618323,-0.029470881,-0.04381535,0.055211045,-0.0111715235,-0.004484313,-0.02654065,-0.022317547,-0.027823675,0.0135190515,0.001530742,-0.04323672,-0.028350104,-0.07154715,-0.0024147208,0.031836234,0.03476004,0.033611998,0.038179073,-0.087631755,-0.048408568,-0.11773682,-0.019127818,0.013682835,-0.02015055,0.01888005,-0.03280704,0.0076310635,0.074330166,-0.031277154,0.056628436,0.119448215,-0.0012235055,-0.009727585,-0.05459528,0.04298459,0.054554865,-0.027898816,0.0040641865,0.08585007,-0.053415824,-0.030528797,-0.08231634,-0.069264784,-0.08337459,0.049254872,-0.021684796,0.12479715,0.053940497,-0.038884085,-0.032209005,0.035795107,0.0054665194,0.0085438965,-0.039386917,0.083624765,-0.056901276,0.022051739,0.06955752,-0.0008329906,-0.07959222,0.075660035,-0.017008293,0.015329365,-0.07439257,0.057193674,-0.06564091,0.0007063081,-0.015799401,-0.008529507,0.027204275,0.0076780985,-0.018589584,0.065267086,-0.02026929,-0.0559547,-0.035843417,-0.07237942,0.028072618,-0.048903402,-0.027478782,-0.084877744,-0.040812787,0.026713751,0.016210195,-0.039116003,0.03572044,-0.014964189,0.026315138,-0.08638934,-0.04198059,-0.02164005,0.09299754,-0.047685668,0.061317034,0.035914674,0.03533252,0.0287274,-0.033809293,-0.046841178,-0.042211317,-0.02567011,-0.048029255,0.039492987,0.04906847,0.030969618,0.0066106897,0.025528666,-0.008357054,0.04791732,-0.070402496,0.053391967,-0.06309544,0.06575766,0.06522203,0.060434356,-0.047547556,-0.13597175,-0.048658505,0.009734684,-0.016258504,-0.034227647,0.05382081,0.001330341,0.011890187,-0.047945525,-0.031132223,0.0010349775,0.030007072,0.12059559,-0.060273632,-0.010099646,0.055261053,0.053757478,-0.045518342,-0.041972063,-0.08315036,0.049884394,0.037543204,0.17598632,-0.0027433096,0.015989233,0.017486975,0.0059954696,-0.022668751,0.05677827,0.029728843,0.0011321013,-0.051546678,0.1113402,0.017779723,0.050953783,0.10342974,0.04067395,0.054890294,0.017487328,-0.020321153,0.062171113,0.07234749,-0.06777497,-0.03888628,0.08744684,0.032227095,-0.04398878,-0.049698275,-0.0018518695,-0.015967874,-0.0415869,-0.022655524,0.03596353,0.07130526,0.056296617,-0.06720573,-0.092787154,0.021057911,0.015628621,-0.04396636,-0.0063872878,-0.0127499355,0.01633339,-0.0006204544,0.0438727} + 2 | {-0.11384405,0.067140445,0.004428383,-0.019213142,0.011713443,0.009808596,0.06439777,-0.014959955,-0.03600561,0.01949383,0.04094742,0.030407589,-0.026018979,0.044171993,0.022412317,-0.057937913,-0.05182386,0.07793179,-0.109105654,0.057499174,0.102279164,-0.04705679,0.0010215766,-0.052305017,-0.0064890077,-0.019298203,0.0027092565,0.07363092,-0.010116459,-0.12196041,-0.025577176,0.010314696,0.031369787,-0.020949671,0.08722754,-0.051809352,0.0007810379,0.07672705,-0.008455481,0.06511949,-0.021327827,-0.060510863,0.044916406,-0.08674781,-0.047401372,-0.01868107,-0.075262256,-0.055392392,0.072947465,-0.01151735,-0.0072187134,0.015544381,0.039965566,0.020232335,0.04894269,0.04900096,0.05358905,0.032501124,0.053288646,0.07584814,0.031957388,0.05976136,-0.12726106,0.103460334,0.06346268,0.06554993,-0.045167506,0.012330433,-0.062929176,0.043507233,-0.008544882,0.027812833,-0.040016085,0.055822216,-0.03835489,0.040096387,0.018063055,0.060356017,-0.0726533,-0.0671456,-0.05047295,-0.042710193,-0.042777598,-0.006822609,0.012524907,-0.032105528,0.026691807,-0.05756205,0.015424967,-0.04767447,-0.036748573,-0.02527533,0.025934244,-0.033328723,-4.1858173e-05,-0.027706677,0.047805857,0.00018475522,0.050902035,0.1352519,0.005388455,0.029921843,-0.02537518,-0.058101207,-0.021984883,-0.059336115,0.03498545,-0.052446626,0.022411253,0.0060822135,-0.068493545,-0.013820616,-0.03522277,-0.018971028,0.07487064,-0.0009035772,-0.009381329,-0.04850395,0.001105027,0.016467793,0.0268643,0.0013964645,0.043346133,-0.009041368,0.07489963,-0.07887815,0.068340026,0.03767777,0.11665796,-0.025433592,0.062018104,-0.030672694,-0.012993033,0.0068405713,-0.03688894,-0.022034604,-0.040981747,-0.033101898,0.071058825,-0.0017327801,-0.021141728,-0.07144207,-0.02906128,-0.095396295,0.006055787,0.08500532,-0.031142898,0.055712428,-0.041926548,-0.042101618,-0.013311086,-0.046836447,0.023902802,0.031264246,-0.012085872,0.042904463,0.011645057,0.049069524,-0.0039288886,-0.014362478,-0.06809574,-0.038734697,0.028410498,0.12843607,0.090781115,-0.119838186,0.016676102,0.0009924435,0.0314442,-0.040607806,0.0020882064,0.044765383,0.01829387,-0.05677682,0.08415222,-0.06399008,-0.010945022,-0.024140757,0.046428833,-0.0651499,0.041250102,-0.06294866,-0.032783676,0.047456875,0.034612734,-0.021892011,-0.050926965,-0.06388983,-0.031164767,0.053277884,-0.069394015,0.03465082,-0.0410735,0.03736871,0.010950864,0.01830701,-0.070063934,-0.06988279,-0.03560967,-0.05519299,0.07882521,0.05533408,-0.02321644,0.007326457,-0.05126765,0.045479607,0.01830127,-0.037239183,-0.08015762,-0.056017533,-0.07647084,-0.0065865014,-0.027235825,-0.039984804,-0.0156225115,-0.014561295,0.024489071,0.009097713,0.04265267,-0.003169223,0.010329996,-0.078917705,-0.026417341,-0.13925064,-0.009786513,-0.037679326,-0.023494951,0.016230932,-0.010068113,0.008919443,0.05672694,-0.0647096,0.0074613485,0.0856074,-0.0072963624,-0.04508945,-0.027654354,0.031864826,0.046863783,-0.032239847,-0.024967564,0.065593235,-0.05142123,-0.011477745,-0.083396286,-0.036403924,-0.030264381,0.060208946,-0.037968345,0.13118903,0.055968005,-0.02204113,-0.00871512,0.06265703,0.024767108,0.06307163,-0.093918525,0.06388834,-0.027308429,0.028177679,0.046643235,-0.008643308,-0.08599351,0.08742052,-0.0045658057,0.009925819,-0.061982065,0.06666853,-0.085638665,-0.008682048,0.016528588,-0.015443429,0.040419903,0.0059123226,-0.04848474,0.026133329,-0.042095724,-0.06860905,-0.033551272,-0.06492134,0.019667841,-0.04917464,-0.0096588,-0.10072659,-0.07769663,0.03221359,0.019174514,0.039727442,0.025392585,-0.016384942,0.0024048705,-0.09175566,-0.03225071,0.0066428655,0.10759633,-0.04011207,0.031578932,0.06299788,0.061487168,0.048043367,-0.0047893273,-0.054848563,-0.06647676,-0.027905045,-0.055799212,0.028914401,0.04013868,0.050728165,-0.0063177645,-0.018899892,0.008193828,0.025991635,-0.08009935,0.044058595,-0.046858713,0.072079815,0.046664152,0.019002488,-0.018447064,-0.15560018,-0.050175466,0.001016439,-0.0035773942,-0.025972001,0.047064543,0.01866733,0.0049167247,-0.052880444,-0.029235922,-0.024581103,0.040634423,0.095990844,-0.019483034,-0.02325509,0.056078408,0.09241045,-0.03079215,-0.023518562,-0.08394134,0.03326668,0.008070111,0.14776507,0.030338759,-0.01846056,0.009517991,0.0034727904,0.007246884,0.015436005,0.058226254,-0.037932027,-0.04309255,0.09766471,0.014914252,0.03149386,0.10146584,0.009303289,0.05649276,0.04743103,-0.016993523,0.054828145,0.033858124,-0.059207607,-0.027288152,0.09254907,0.07817234,-0.047911037,-0.023988279,-0.067968085,-0.03140125,-0.02434741,-0.017226815,0.050405838,0.048384074,0.10386314,-0.05366119,-0.048218876,0.022471255,-0.04470827,-0.055776954,0.0146418335,-0.03505756,0.041757654,0.0076765255,0.0637766} + 3 | {-0.06530473,0.043326367,0.027487691,-0.012605501,-0.003679171,0.0068843057,0.093755856,-0.018192727,-0.038994554,0.060702052,0.047350235,0.0015797003,-0.026038624,0.029946782,0.053223953,-0.009188536,-0.012273773,0.07512682,-0.1220027,0.024623549,0.040207546,-0.061494265,-0.0016338134,-0.096063755,-0.020626824,-0.0008177105,0.025736991,0.08205663,-0.064413406,-0.10329614,-0.050153203,0.022038238,-0.011629073,-0.03142779,0.09684598,-0.045188677,-0.032773193,0.041901052,0.032470446,0.06218501,0.00056252955,-0.03571358,0.030095506,-0.09239761,-0.020187493,-0.00932361,-0.08373726,-0.053929392,0.09724756,-0.032078817,0.02658544,0.009965162,0.07477913,0.05487153,0.023828406,0.06263976,0.06882497,0.08249143,0.062069558,0.08915651,-0.005154778,0.056259956,-0.13729677,0.08404741,0.07149277,0.04482675,-0.058625933,0.0034976404,-0.030747578,0.004520399,0.0007449915,9.660358e-05,-0.022526976,0.11449101,-0.043607008,0.026769284,0.021050733,0.05854427,-0.042627476,-0.022924222,-0.059794623,-0.037738875,-0.018500011,0.017315088,-0.00020744087,-0.0016206327,0.013337528,-0.022439854,-0.0042932644,-0.04706647,-0.06771751,-0.040391076,0.0638978,-0.031776994,0.011536817,-0.04593729,0.08626801,0.0016808647,-0.0046028513,0.13702579,0.02293593,0.043189116,-0.0073873955,-0.06097065,-0.019305069,-0.025651531,0.043129053,-0.033460874,0.03261353,-0.022361644,-0.07769732,-0.021210406,-0.020294553,-0.044899672,0.083500296,0.038056396,-0.052046232,-0.03215008,-0.028185,0.041909587,0.016012225,-0.0058236965,0.021344814,-0.037620485,0.07454872,-0.03517924,0.086520284,0.096695796,0.0937938,-0.04190071,0.072271764,-0.07022541,0.01583733,-0.0017275782,-0.05280332,-0.005904967,-0.046241984,-0.024421731,0.09988276,-0.0077029592,-0.04107849,-0.091607556,0.033811443,-0.1323201,-0.015927043,0.011014193,-0.039773338,0.033963792,-0.053305525,-0.005038948,-0.024107914,-0.0079898145,0.039604105,0.009226985,0.0010978039,-0.015565131,-0.0002796709,0.037623808,-0.059376597,0.015390821,-0.07600872,-0.008280972,0.023050148,0.0777234,0.061332665,-0.13979945,-0.009342198,0.012803744,0.049805813,-0.03578894,-0.05038778,0.048912454,0.032017626,0.015345221,0.10369494,-0.048897773,-0.054201737,-0.015793057,0.08130064,-0.064783126,0.074246705,-0.06964914,-0.025839275,0.030869238,0.06357789,-0.028754702,-0.02960897,-0.04956488,0.030501548,0.005857936,-0.023547728,0.03717584,0.0024309678,0.066338174,-0.009775384,-0.030799516,-0.028462514,-0.058787093,-0.051071096,-0.048674088,0.011397957,0.07817651,-0.03227047,0.027149512,-0.0030777291,0.061677814,0.0025318298,-0.027110869,-0.0691719,-0.033963803,-0.0648151,-0.033951994,-0.0478505,0.0016642202,-0.019602248,-0.030472266,0.015889537,-0.0009066139,0.032841947,0.021004336,-0.029254122,-0.09597239,-0.04359093,-0.15422617,-0.016366383,-0.059343938,-0.064871244,0.07659653,0.023196936,-0.021893008,0.080793895,-0.05248758,0.018764181,0.0008353451,-0.03318359,-0.04830206,-0.05518034,0.038481984,0.06544077,0.019498836,-0.054670736,0.040052623,-0.028875519,-0.047129385,-0.03614192,-0.012638911,-0.0042204396,0.013685266,-0.047130045,0.11024768,0.07135732,-0.017937008,-0.040911496,0.09008783,0.039298594,0.042975742,-0.08974752,0.08711358,-0.021977019,0.051495675,0.0140351625,-0.053809136,-0.08241595,0.04982693,-0.020355707,0.017629888,-0.039196398,0.08688628,-0.051167585,-0.029257154,0.009161573,-0.0021740724,0.027258197,0.015352816,-0.07426982,0.022452697,-0.041628033,-0.023250584,-0.051996145,-0.031867135,-0.01930267,-0.05257186,0.032619886,-0.08220233,-0.017010445,0.038414452,-0.02268424,0.007727591,0.0064041745,-0.024256933,0.0028989788,-0.06191567,-0.020444075,-0.010515549,0.08980986,-0.020033991,0.009208651,0.044014987,0.067944355,0.07915397,0.019362122,-0.010731527,-0.057449125,-0.007854527,-0.067998596,0.036500365,0.037355963,-0.0011789168,0.030410502,-0.012768641,-0.03281059,0.026916556,-0.052477527,0.042145997,-0.023683913,0.099338256,0.035008017,-0.029086927,-0.032222193,-0.14743629,-0.04350868,0.030494612,-0.013000542,0.021753347,0.023393912,0.021320568,0.0031570331,-0.06008047,-0.031103736,0.030275675,0.015258714,0.09004704,0.0033432578,-0.0045539658,0.06602429,0.072156474,-0.0613405,-0.047462273,-0.057639644,-0.008026253,0.03090332,0.12396069,0.04592149,-0.053269017,0.034282286,-0.0045666047,-0.026025562,0.004598449,0.04304216,-0.02252559,-0.040372007,0.08094969,-0.021883471,0.05903653,0.10130699,0.001840184,0.06142003,0.004450253,-0.023686321,0.014760433,0.07669066,-0.08392746,-0.028447477,0.08995419,0.028487092,-0.047503598,-0.026627144,-0.0475691,-0.069141485,-0.039571274,-0.054866526,0.04417342,0.08155949,0.065555565,-0.053984754,-0.04142323,-0.023902748,0.0066344747,-0.065118864,0.02183451,-0.06479133,0.010425607,-0.010283142,0.0940532} +``` + +!!! + +!!! + +You can see the near 2.5x speedup when generating 3 embeddings in a batch, because the model weights only need to be streamed from GPU RAM to the processors a single time. You should consider batch sizes from 10-100 embeddings at a time when do bulk operations to improve throughput and reduce costs. + +## Scalability + +PostgresML serverless instances have access to multiple GPUs that be used simultaneously across different PostgreSQL connections. For large jobs, you may want to create multiple worker threads/processes that operate across your dataset in batches on their own Postgres Connection. + diff --git a/pgml-cms/docs/guides/embeddings/indexing-w-pgvector.md b/pgml-cms/docs/guides/embeddings/indexing-w-pgvector.md new file mode 100644 index 000000000..e361d5aff --- /dev/null +++ b/pgml-cms/docs/guides/embeddings/indexing-w-pgvector.md @@ -0,0 +1 @@ +# Indexing w/ pgvector diff --git a/pgml-cms/docs/guides/embeddings/proprietary-models.md b/pgml-cms/docs/guides/embeddings/proprietary-models.md new file mode 100644 index 000000000..e69de29bb diff --git a/pgml-cms/docs/guides/embeddings/re-ranking-nearest-neighbors.md b/pgml-cms/docs/guides/embeddings/re-ranking-nearest-neighbors.md new file mode 100644 index 000000000..a8945376a --- /dev/null +++ b/pgml-cms/docs/guides/embeddings/re-ranking-nearest-neighbors.md @@ -0,0 +1,3 @@ +# Re-ranking Nearest Neighbors + +## Introduction diff --git a/pgml-cms/docs/guides/embeddings/vector-aggregation.md b/pgml-cms/docs/guides/embeddings/vector-aggregation.md new file mode 100644 index 000000000..2b6e09209 --- /dev/null +++ b/pgml-cms/docs/guides/embeddings/vector-aggregation.md @@ -0,0 +1,98 @@ +--- +description: Vector aggregation is extensively used across various machine learning applications, including NLP, Image Processing, Recommender Systems, Time Series Analysis with strong benefits. +--- + +# Vector Aggregation + +Vector aggregation in the context of embeddings refers to the process of combining multiple vector representations into a single, unified vector. This technique is particularly useful in machine learning and data science, especially when dealing with embeddings from natural language processing (NLP), image processing, or any domain where objects are represented as high-dimensional vectors. + +## Understanding Vector Aggregation +Embeddings are dense vector representations of objects (like words, sentences, or images) that capture their underlying semantic properties in a way that is understandable by machine learning models. When dealing with multiple such embeddings, it might be necessary to aggregate them to produce a single representation that captures the collective properties of all the items in the set. + +## Applications in Machine Learning +Vector aggregation is extensively used across various machine learning applications. + +### Natural Language Processing +**Sentence or Document Embedding**: Individual word embeddings within a sentence or document can be aggregated to form a single vector representation of the entire text. This aggregated vector can then be used for tasks like text classification, sentiment analysis, or document clustering. + +**Information Retrieval**: Aggregated embeddings can help in summarizing multiple documents or in query refinement, where the query and multiple documents' embeddings are aggregated to improve search results. + +### Image Processing +**Feature Aggregation**: In image recognition or classification, features extracted from different parts of an image (e.g., via convolutional neural networks) can be aggregated to form a global feature vector. + +### Recommender Systems +**User or Item Profiles**: Aggregating item embeddings that a user has interacted with can create a dense representation of a user's preferences. Similarly, aggregating user embeddings for a particular item can help in understanding the item’s appeal across different user segments. + +### Time Series Analysis +**Temporal Data Aggregation**: In scenarios where temporal dynamics are captured via embeddings at different time steps (e.g., stock prices, sensor data), these can be aggregated to form a representation of the overall trend or to capture cyclical patterns. + +## Benefits of Vector Aggregation +- **Dimensionality Reduction**: Aggregation can reduce the complexity of handling multiple embeddings, making the data easier to manage and process. +- **Noise Reduction**: Averaging and other aggregation methods can help mitigate the effect of noise in individual data points, leading to more robust models. +- **Improved Learning Efficiency**: By summarizing data, aggregation can speed up learning processes and improve the performance of machine learning algorithms on large datasets. + +## Available Methods of Vector Aggregation + +### Example Data +```postgresql +CREATE TABLE documents ( + id SERIAL PRIMARY KEY, + body TEXT, + embedding FLOAT[] GENERATED ALWAYS AS (pgml.embed('intfloat/e5-small-v2', body)) STORED +); +``` + +Example of inserting text and its corresponding embedding + +```postgresql +INSERT INTO documents (body) +VALUES -- embedding vectors are automatically generated + ('Example text data'), + ('Another example document'), + ('Some other thing'); +``` + +### Summation +Adding up all the vectors element-wise. This method is simple and effective, preserving all the information from the original vectors, but can lead to large values if many vectors are summed. + +```postgresql +SELECT id, pgml.sum(embedding) +FROM documents +GROUP BY id; +``` + +### Averaging (Mean) +Computing the element-wise mean of the vectors. This is probably the most common aggregation method, as it normalizes the scale of the vectors against the number of vectors being aggregated, preventing any single vector from dominating the result. + +```postgresql +SELECT id, pgml.divide(pgml.sum(embedding), count(*)) AS avg +FROM documents +GROUP BY id; +``` + +### Weighted Average +Similar to averaging, but each vector is multiplied by a weight that reflects its importance before averaging. This method is useful when some vectors are more significant than others. + +```postgresql +SELECT id, pgml.divide(pgml.sum(pgml.multiply(embedding, id)), count(*)) AS id_weighted_avg +FROM documents +GROUP BY id; +``` + +### Max Pooling +Taking the maximum value of each dimension across all vectors. This method is particularly useful for capturing the most pronounced features in a set of vectors. + +```postgresql +SELECT id, pgml.max_abs(embedding) +FROM documents +GROUP BY id; +``` + +### Min Pooling +Taking the minimum value of each dimension across all vectors, useful for capturing the least dominant features. + +```postgresql +SELECT id, pgml.min_abs(embedding) +FROM documents +GROUP BY id; +``` \ No newline at end of file diff --git a/pgml-cms/docs/guides/embeddings/vector-normalization.md b/pgml-cms/docs/guides/embeddings/vector-normalization.md new file mode 100644 index 000000000..31cddab00 --- /dev/null +++ b/pgml-cms/docs/guides/embeddings/vector-normalization.md @@ -0,0 +1,93 @@ +# Vector Normalization + +Vector normalization converts a vector into a unit vector — that is, a vector that retains the same direction but has a magnitude (or length) of 1. This process is essential for various computational techniques where the magnitude of a vector may influence the outcome undesirably, such as when calculating the inner product instead of cosine similarity or when needing to compare vectors based solely on direction. + +## Purpose and Benefits + +- **Cosine Similarity**: In machine learning and data science, normalized vectors are crucial when using the inner product, instead of the more expensive cosine similarity metric. Inner product inherently requires vectors of unit length to accurately measure angles between vectors. L2 Normalized vectors indexed with the inner product can reduce computational complexity 3x in the inner loop compared to cosine similarity, while yielding otherwise identical results. + +- **Directionality**: Normalization strips away the magnitude of the vector, leaving a descriptor of direction only. This is useful when direction matters more than length, such as in feature scaling in machine learning where you want to normalize features to have equal influence regardless of their absolute values. + +- **Stability in Computations**: When vectors are normalized, numerical computations involving them are often more stable and less susceptible to problems due to very large or very small scale factors. + +## Storing and Normalizing Data + +Assume you've created a table in your database that stores embeddings generated using [pgml.embed()](../../api/sql-extension/pgml.embed.md), although you can normalize any vector. + +```postgresql +CREATE TABLE documents ( + id SERIAL PRIMARY KEY, + body TEXT, + embedding FLOAT[] GENERATED ALWAYS AS (pgml.embed('intfloat/e5-small-v2', body)) STORED +); +``` + +Example of inserting text and its corresponding embedding + +```postgresql +INSERT INTO documents (body) +VALUES -- embedding vectors are automatically generated + ('Example text data'), + ('Another example document'), + ('Some other thing'); +``` + +You could create a new table from your documents and their embeddings, that uses normalized embeddings. + +```postgresql +CREATE TABLE documents_normalized_vectors AS +SELECT + id AS document_id, + pgml.normalize_l2(embedding) AS normalized_l2_embedding +FROM documents; +``` + +Another valid approach would be to just store the normalized embedding in the documents table. + +```postgresql +CREATE TABLE documents ( + id SERIAL PRIMARY KEY, + body TEXT, + embedding FLOAT[] GENERATED ALWAYS AS (pgml.normalize_l2(pgml.embed('intfloat/e5-small-v2', body))) STORED +); +``` + +## Normalization Functions + Normalization is critical for ensuring that the magnitudes of feature vectors do not distort the performance of machine learning algorithms. + +- **L1 Normalization (Manhattan Norm)**: This function scales the vector so that the sum of the absolute values of its components is equal to 1. It's useful when differences in magnitude are important but the components represent independent dimensions. + + ```postgresql + SELECT pgml.normalize_l1(embedding) FROM documents; + ``` + +- **L2 Normalization (Euclidean Norm)**: Scales the vector so that the sum of the squares of its components is equal to 1. This is particularly important for cosine similarity calculations in machine learning. + + ```postgresql + SELECT pgml.normalize_l2(embedding) FROM documents; + ``` + +- **Max Normalization**: Scales the vector such that the maximum absolute value of any component is 1. This normalization is less common but can be useful when the maximum value represents a bounded capacity. + + ```postgresql + SELECT pgml.normalize_max(embedding) FROM documents; + ``` + +## Querying and Using Normalized Vectors + After normalization, you can use these vectors for various applications, such as similarity searches, clustering, or as input for further machine learning models within PostgresML. + +```postgresql +-- Querying for similarity using l2 normalized dot product, which is equivalent to cosine similarity +WITH normalized_vectors AS ( + SELECT id, pgml.normalize_l2(embedding) AS norm_vector + FROM documents +) +SELECT a.id, b.id, pgml.dot_product(a.norm_vector, b.norm_vector) +FROM normalized_vectors a, normalized_vectors b +WHERE a.id <> b.id; +``` + +## Considerations and Best Practices + +- **Performance**: Normalization can be computationally intensive, especially with large datasets. Consider batch processing and appropriate indexing. +- **Storage**: Normalized vectors might not need to be persisted if they are only used transiently, which can save storage or IO latency. diff --git a/pgml-cms/docs/guides/embeddings/vector-similarity.md b/pgml-cms/docs/guides/embeddings/vector-similarity.md new file mode 100644 index 000000000..f0fa07a1e --- /dev/null +++ b/pgml-cms/docs/guides/embeddings/vector-similarity.md @@ -0,0 +1,356 @@ +# Vector Similarity + +Similar embeddings should represent similar concepts. If we have one embedding created from a user query and a bunch of other embeddings from documents, we can find documents that are most similar to the query by calculating the similarity between the query and each document. Embedding similarity (≈) is defined as the distance between the two vectors. + +There are several ways to measure the distance between two vectors, that have tradeoffs in latency and accuracy. If two vectors are identical (=), then the distance between them is 0. If the distance is small, then they are similar (≈). Here, we explore a few of the more common ones here with details on how they work, to help you choose. It's worth taking the time to understand the differences between these simple formulas, because they are the inner loop that accounts for almost all computation when doing nearest neighbor search. + +They are listed here in order of computational complexity, although modern hardware accelerated implementations can typically compare on the order of 100,000 vectors per second per processor, depending on how many dimensions the vectors have. Modern CPUs may also have tens to hundreds of cores, and GPUs have tens of thousands, to further parallelize searches across large numbers of vectors. + +!!! note + +If you just want the cliff notes: [Normalize your vectors](vector-normalization) and use the inner product as your distance metric between two vectors. This is implemented as: `pgml.dot_product(a, b)` + +!!! + +All of these distance measures are implemented by PostgresML for the native Postgres `ARRAY[]` types, and separately implemented by pgvector as operators for its `VECTOR` types using operators. + +## Manhattan Distance + +You can think of this distance metric as how long it takes you to walk from one building in Manhattan to another, when you can only walk along streets that go the 4 cardinal directions, with no diagonals. It's the fastest distance measure to implement, because it just adds up all the pairwise element differences. It's also referred to as the L1 distance. + +!!! tip + +Most applications should use Euclidean Distance instead, unless accuracy has relatively little value, and nanoseconds are important to your user experience. + +!!! + +**Algorithm** + + +{% tabs %} + +{% tab title="JavaScript" %} + +```javascript +function manhattanDistance(x, y) { + let result = 0; + for (let i = 0; i < x.length; i++) { + result += x[i] - y[i]; + } + return result; +} + +let x = [1, 2, 3]; +let y = [1, 2, 3]; +manhattanDistance(x, y) +``` + +{% endtab %} + +{% tab title="Python" %} + +```python +def manhattan_distance(x, y): + return sum([x-y for x,y in zip(x,y)]) + +x = [1, 2, 3] +y = [1, 2, 3] +manhattan_distance(x, y) +``` + +{% endtab %} +{% endtabs %} + +An optimized version is provided by: + +!!! code_block time="1191.069 ms" + +```postgresql +WITH query AS ( + SELECT vector + FROM test_data + LIMIT 1 +) +SELECT id, pgml.distance_l1(query.vector, test_data.vector) +FROM test_data, query +ORDER BY distance_l1; +``` + +!!! + +The equivalent pgvector operator is `<+>`. + + +## Euclidean Distance + +This is a simple refinement of Manhattan Distance that applies the Pythagorean theorem to find the length of the straight line between the two points. It's also referred to as the L2 distance. It involves squaring the differences and then taking the final square root, which is a more expensive operation, so it may be slightly slower, but is also a more accurate representation in high dimensional spaces. When finding nearest neighbors, the final square root can computation can be omitted, but there are still twice as many operations in the inner loop. + + +!!! tip + +Most applications should use Inner product for better accuracy with less computation, unless you can't afford to normalize your vectors before indexing for some extremely write heavy application. + +!!! + +**Algorithm** + +{% tabs %} +{% tab title="JavaScript" %} + +```javascript +function euclideanDistance(x, y) { + let result = 0; + for (let i = 0; i < x.length; i++) { + result += Math.pow(x[i] - y[i], 2); + } + return Math.sqrt(result); +} + +let x = [1, 2, 3]; +let y = [1, 2, 3]; +euclideanDistance(x, y) +``` + +{% endtab %} + +{% tab title="Python" %} + +```python +def euclidean_distance(x, y): + return math.sqrt(sum([(x-y) * (x-y) for x,y in zip(x,y)])) + +x = [1, 2, 3] +y = [1, 2, 3] +euclidean_distance(x, y) +``` + +{% endtab %} +{% endtabs %} + +An optimized version is provided by: + +!!! code_block time="1359.114 ms" + +```postgresql +WITH query AS ( + SELECT vector + FROM test_data + LIMIT 1 +) +SELECT id, pgml.distance_l2(query.vector, test_data.vector) +FROM test_data, query +ORDER BY distance_l2; +``` + +!!! + +The equivalent pgvector operator is `<->`. + +## Inner product + +The inner product (the dot product in Euclidean space) can be used to find how similar any two vectors are, by measuring the overlap of each element, which compares the direction they point. Two completely different (orthogonal) vectors have an inner product of 0. If vectors point in opposite directions, the inner product will be negative. Positive numbers indicate the vectors point in the same direction, and are more similar. + +This metric is as fast to compute as the Euclidean Distance, but may provide more relevant results if all vectors are normalized. If vectors are not normalized, it will bias results toward vectors with larger magnitudes, and you should consider using the cosine distance instead. + +!!! tip + +This is probably the best all around distance metric. It's computationally simple, but also twice as fast due to optimized assembly intructions. It's also able to places more weight on the dominating dimensions of the vectors which can improve relevance during recall. As long as [your vectors are normalized](vector-normalization). + +!!! + +**Algorithm** + +{% tabs %} +{% tab title="JavaScript" %} + +```javascript +function innerProduct(x, y) { + let result = 0; + for (let i = 0; i < x.length; i++) { + result += x[i] * y[i]; + } + return result; +} + +let x = [1, 2, 3]; +let y = [1, 2, 3]; +innerProduct(x, y) +``` + +{% endtab %} + +{% tab title="Python" %} + +```python +def inner_product(x, y): + return sum([x*y for x,y in zip(x,y)]) + +x = [1, 2, 3] +y = [1, 2, 3] +inner_product(x, y) +``` + +{% endtab %} +{% endtabs %} + +An optimized version is provided by: + +!!! code_block time="498.649 ms" + +```postgresql +WITH query AS ( + SELECT vector + FROM test_data + LIMIT 1 +) +SELECT id, pgml.dot_product(query.vector, test_data.vector) +FROM test_data, query +ORDER BY dot_product; +``` + +!!! + +The equivalent pgvector operator is `<#>`. + + +## Cosine Distance + +Cosine distance is a popular metric, because it normalizes the vectors, which means it only considers the difference of the angle between the two vectors, not their magnitudes. If you don't know that your vectors have been normalized, this may be a safer bet than the inner product. It is one of the more complicated algorithms to implement, but differences may be negligible w/ modern hardware accelerated instruction sets depending on your workload profile. + +!!! tip + +Use PostgresML to [normalize all your vectors](vector-normalization) as a separate processing step to pay that cost only at indexing time, and then switch to the inner product which will provide equivalent distance measures, at 1/3 of the computation in the inner loop. _That's not exactly true on all platforms_, because the inner loop is implemented with optimized assembly that can take advantage of additional hardware acceleration, so make sure to always benchmark on your own hardware. On our hardware, the performance difference is negligible. + +!!! + +**Algorithm** + +{% tabs %} +{% tab title="JavaScript" %} + +```javascript +function cosineDistance(a, b) { + let dotProduct = 0; + let normA = 0; + let normB = 0; + + for (let i = 0; i < a.length; i++) { + dotProduct += a[i] * b[i]; + normA += a[i] * a[i]; + normB += b[i] * b[i]; + } + + normA = Math.sqrt(normA); + normB = Math.sqrt(normB); + + if (normA === 0 || normB === 0) { + throw new Error("Norm of one or both vectors is 0, cannot compute cosine similarity."); + } + + const cosineSimilarity = dotProduct / (normA * normB); + const cosineDistance = 1 - cosineSimilarity; + + return cosineDistance; +} +``` +{% endtab %} + +{% tab title="Python" %} + +```python +def cosine_distance(a, b): + dot_product = 0 + normA = 0 + normB = 0 + + for a, b in zip(a, b): + dot_product += a * b + normA += a * a + normB += b * b + + normA = math.sqrt(normA) + normB = math.sqrt(normB) + + if normA == 0 or normB == 0: + raise ValueError("Norm of one or both vectors is 0, cannot compute cosine similarity.") + + cosine_similarity = dot_product / (normA * normB) + cosine_distance = 1 - cosine_similarity + + return cosine_distance +``` + +{% endtab %} +{% endtabs %} + +The optimized version is provided by: + +!!! code_block time="508.587 ms" + +```postgresql +WITH query AS ( + SELECT vector + FROM test_data + LIMIT 1 +) +SELECT id, 1 - pgml.cosine_similarity(query.vector, test_data.vector) AS cosine_distance +FROM test_data, query +ORDER BY cosine_distance; +``` + +!!! + +Or you could reverse order by `cosine_similarity` for the same ranking: + +!!! code_block time="502.461 ms" + +```postgresql +WITH query AS ( + SELECT vector + FROM test_data + LIMIT 1 +) +SELECT id, pgml.cosine_similarity(query.vector, test_data.vector) +FROM test_data, query +ORDER BY cosine_similarity DESC; +``` + +!!! + +The equivalent pgvector operator is `<=>`. + +## Benchmarking + +You should benchmark and compare the computational cost of these distance metrics to see how much they algorithmic differences matters for latency using the same vector sizes as your own data. We'll create some test data to demonstrate the relative costs associated with each distance metric. + +!!! code_block + +```postgresql +\timing on +``` + +!!! + +!!! code_block + +```postgresql +CREATE TABLE test_data ( + id BIGSERIAL NOT NULL, + vector FLOAT4[] +); +``` + +!!! + +Insert 10k vectors, that have 1k dimensions each + +!!! code_block + +```postgresql +INSERT INTO test_data (vector) +SELECT array_agg(random()) +FROM generate_series(1,10000000) i +GROUP BY i % 10000; +``` + +!!! diff --git a/pgml-cms/docs/use-cases/improve-search-results-with-machine-learning.md b/pgml-cms/docs/guides/improve-search-results-with-machine-learning.md similarity index 99% rename from pgml-cms/docs/use-cases/improve-search-results-with-machine-learning.md rename to pgml-cms/docs/guides/improve-search-results-with-machine-learning.md index 5a6f20cef..0fde75c55 100644 --- a/pgml-cms/docs/use-cases/improve-search-results-with-machine-learning.md +++ b/pgml-cms/docs/guides/improve-search-results-with-machine-learning.md @@ -14,7 +14,7 @@ Our search application will start with a **documents** table. Our documents have !!! code\_block time="10.493 ms" -```sql +```postgresql CREATE TABLE documents ( id BIGSERIAL PRIMARY KEY, title TEXT, @@ -32,7 +32,7 @@ We can add new documents to our _text corpus_ with the standard SQL `INSERT` sta !!! code\_block time="3.417 ms" -```sql +```postgresql INSERT INTO documents (title, body) VALUES ('This is a title', 'This is the body of the first document.'), ('This is another title', 'This is the body of the second document.'), @@ -57,7 +57,7 @@ You can configure the grammatical rules in many advanced ways, but we'll use the !!! code\_block time="0.651 ms" -```sql +```postgresql SELECT * FROM documents WHERE to_tsvector('english', body) @@ to_tsquery('english', 'second'); @@ -87,7 +87,7 @@ The first step is to store the `tsvector` in the table, so we don't have to gene !!! code\_block time="17.883 ms" -```sql +```postgresql ALTER TABLE documents ADD COLUMN title_and_body_text tsvector GENERATED ALWAYS AS (to_tsvector('english', title || ' ' || body )) STORED; @@ -103,7 +103,7 @@ One nice aspect of generated columns is that they will backfill the data for exi !!! code\_block time="5.145 ms" -```sql +```postgresql CREATE INDEX documents_title_and_body_text_index ON documents USING GIN (title_and_body_text); @@ -119,7 +119,7 @@ And now, we'll demonstrate a slightly more complex `tsquery`, that requires both !!! code\_block time="3.673 ms" -```sql +```postgresql SELECT * FROM documents WHERE title_and_body_text @@ to_tsquery('english', 'another & second'); @@ -149,7 +149,7 @@ With multiple query terms OR `|` together, the `ts_rank` will add the numerators !!! code\_block time="0.561 ms" -```sql +```postgresql SELECT ts_rank(title_and_body_text, to_tsquery('english', 'second | title')), * FROM documents ORDER BY ts_rank DESC; @@ -179,7 +179,7 @@ A quick improvement we could make to our search query would be to differentiate !!! code\_block time="0.561 ms" -```sql +```postgresql SELECT ts_rank(title, to_tsquery('english', 'second | title')) AS title_rank, ts_rank(body, to_tsquery('english', 'second | title')) AS body_rank, @@ -208,7 +208,7 @@ First things first, we need to record some user clicks on our search results. We !!! code\_block time="0.561 ms" -```sql +```postgresql CREATE TABLE search_result_clicks ( title_rank REAL, body_rank REAL, @@ -228,7 +228,7 @@ I've made up 4 example searches, across our 3 documents, and recorded the `ts_ra !!! code\_block time="2.161 ms" -```sql +```postgresql INSERT INTO search_result_clicks (title_rank, body_rank, clicked) VALUES @@ -267,7 +267,7 @@ Here goes some machine learning: !!! code\_block time="6.867 ms" -```sql +```postgresql SELECT * FROM pgml.train( project_name => 'Search Ranking', task => 'regression', @@ -314,7 +314,7 @@ Once a model is trained, you can use `pgml.predict` to use it on new inputs. `pg !!! code\_block time="3.119 ms" -```sql +```postgresql SELECT clicked, pgml.predict('Search Ranking', array[title_rank, body_rank]) @@ -367,7 +367,7 @@ It's nice to organize the query into logical steps, and we can use **Common Tabl !!! code\_block time="2.118 ms" -```sql +```postgresql WITH first_pass_ranked_documents AS ( SELECT -- Compute the ts_rank for the title and body text of each document diff --git a/pgml-cms/docs/use-cases/natural-language-processing.md b/pgml-cms/docs/guides/natural-language-processing.md similarity index 100% rename from pgml-cms/docs/use-cases/natural-language-processing.md rename to pgml-cms/docs/guides/natural-language-processing.md diff --git a/pgml-cms/docs/use-cases/opensourceai.md b/pgml-cms/docs/guides/opensourceai.md similarity index 100% rename from pgml-cms/docs/use-cases/opensourceai.md rename to pgml-cms/docs/guides/opensourceai.md diff --git a/pgml-cms/docs/use-cases/supervised-learning.md b/pgml-cms/docs/guides/supervised-learning.md similarity index 98% rename from pgml-cms/docs/use-cases/supervised-learning.md rename to pgml-cms/docs/guides/supervised-learning.md index 8dcf59dd9..6d7b4dc2d 100644 --- a/pgml-cms/docs/use-cases/supervised-learning.md +++ b/pgml-cms/docs/guides/supervised-learning.md @@ -8,7 +8,7 @@ description: A machine learning approach that uses labeled data A large part of the machine learning workflow is acquiring, cleaning, and preparing data for training algorithms. Naturally, we think Postgres is a great place to store your data. For the purpose of this example, we'll load a toy dataset, the classic handwritten digits image collection, from scikit-learn. -```sql +```postgresql SELECT * FROM pgml.load_dataset('digits'); ``` @@ -25,7 +25,7 @@ This `NOTICE` can safely be ignored. PostgresML attempts to do a clean reload by PostgresML loaded the Digits dataset into the `pgml.digits` table. You can examine the 2D arrays of image data, as well as the label in the `target` column: -```sql +```postgresql SELECT target, image @@ -48,7 +48,7 @@ target | Now that we've got data, we're ready to train a model using an algorithm. We'll start with the default `linear` algorithm to demonstrate the basics. See the [Algorithms](../../../docs/training/algorithm\_selection/) for a complete list of available algorithms. -```sql +```postgresql SELECT * FROM pgml.train( 'Handwritten Digit Image Classifier', 'classification', @@ -85,7 +85,7 @@ The output gives us information about the training run, including the `deployed` Now we can inspect some of the artifacts a training run creates. -```sql +```postgresql SELECT * FROM pgml.overview; ``` @@ -105,7 +105,7 @@ The `pgml.predict()` function is the key value proposition of PostgresML. It pro The API for predictions is very simple and only requires two arguments: the project name and the features used for prediction. -```sql +```postgresql select pgml.predict ( project_name TEXT, features REAL[] @@ -154,7 +154,7 @@ LIMIT 25; If you've already been through the [Training Overview](../../../docs/training/overview/), you can see the results of those efforts: -```sql +```postgresql SELECT target, pgml.predict('Handwritten Digit Image Classifier', image) AS prediction @@ -182,7 +182,7 @@ LIMIT 10; Since it's so easy to train multiple algorithms with different hyperparameters, sometimes it's a good idea to know which deployed model is used to make predictions. You can find that out by querying the `pgml.deployed_models` view: -```sql +```postgresql SELECT * FROM pgml.deployed_models; ``` @@ -201,7 +201,7 @@ Take a look at [Deploying Models](../../../docs/predictions/deployments/) docume You may also specify a model\_id to predict rather than a project name, to use a particular training run. You can find model ids by querying the `pgml.models` table. -```sql +```postgresql SELECT models.id, models.algorithm, models.metrics FROM pgml.models JOIN pgml.projects @@ -220,7 +220,7 @@ recision": 0.9175060987472534, "score_time": 0.019625699147582054} For example, making predictions with `model_id = 1`: -```sql +```postgresql SELECT target, pgml.predict(1, image) AS prediction diff --git a/pgml-cms/docs/introduction/getting-started/import-your-data/copy.md b/pgml-cms/docs/introduction/getting-started/import-your-data/copy.md index 29b22b684..850f73b6e 100644 --- a/pgml-cms/docs/introduction/getting-started/import-your-data/copy.md +++ b/pgml-cms/docs/introduction/getting-started/import-your-data/copy.md @@ -73,6 +73,6 @@ We took our export command and changed `TO` to `FROM`, and that's it. Make sure If your data changed, repeat this process again. To avoid duplicate entries in your table, you can truncate (or delete) all rows beforehand: -```sql +```postgresql TRUNCATE your_table; ``` diff --git a/pgml-cms/docs/product/vector-database.md b/pgml-cms/docs/product/vector-database.md index 00086dae2..825b24eaa 100644 --- a/pgml-cms/docs/product/vector-database.md +++ b/pgml-cms/docs/product/vector-database.md @@ -48,7 +48,7 @@ At first, the column is empty. To generate embeddings, we can use the PostgresML {% tabs %} {% tab title="SQL" %} -```sql +```postgresql UPDATE usa_house_prices SET embedding = pgml.embed( @@ -72,7 +72,7 @@ That's it. We just created 5,000 embeddings of the values stored in the address {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT address, (embedding::real[])[1:5] @@ -115,7 +115,7 @@ For example, if we wanted to find three closest matching addresses to `1 Infinit {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT address FROM usa_house_prices @@ -206,7 +206,7 @@ CREATE INDEX {% tabs %} {% tab title="SQL" %} -```sql +```postgresql EXPLAIN SELECT address FROM usa_house_prices diff --git a/pgml-cms/docs/resources/benchmarks/ggml-quantized-llm-support-for-huggingface-transformers.md b/pgml-cms/docs/resources/benchmarks/ggml-quantized-llm-support-for-huggingface-transformers.md index 86e48ed91..1b74e60e4 100644 --- a/pgml-cms/docs/resources/benchmarks/ggml-quantized-llm-support-for-huggingface-transformers.md +++ b/pgml-cms/docs/resources/benchmarks/ggml-quantized-llm-support-for-huggingface-transformers.md @@ -25,7 +25,7 @@ You can select the data type for torch tensors in PostgresML by setting the `tor !!! code\_block time="4584.906 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "model": "tiiuae/falcon-7b-instruct", @@ -86,7 +86,7 @@ PostgresML will automatically use GPTQ or GGML when a HuggingFace model has one !!! code\_block time="281.213 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -117,7 +117,7 @@ SELECT pgml.transform( !!! code\_block time="252.213 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -148,7 +148,7 @@ SELECT pgml.transform( !!! code\_block time="279.888 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -185,7 +185,7 @@ We can specify the CPU by passing a `"device": "cpu"` argument to the `task`. !!! code\_block time="266.997 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -217,7 +217,7 @@ SELECT pgml.transform( !!! code\_block time="33224.136 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -255,7 +255,7 @@ HuggingFace and these libraries have a lot of great models. Not all of these mod !!! code\_block time="3411.324 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -287,7 +287,7 @@ SELECT pgml.transform( !!! code\_block time="4198.817 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -319,7 +319,7 @@ SELECT pgml.transform( !!! code\_block time="4198.817 ms" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -353,7 +353,7 @@ Many of these models are published with multiple different quantization methods !!! code\_block time="6498.597" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", @@ -391,7 +391,7 @@ Shoutout to [Tostino](https://github.com/Tostino/) for the extended example belo !!! code\_block time="3784.565" -```sql +```postgresql SELECT pgml.transform( task => '{ "task": "text-generation", diff --git a/pgml-cms/docs/resources/benchmarks/mindsdb-vs-postgresml.md b/pgml-cms/docs/resources/benchmarks/mindsdb-vs-postgresml.md index 414068275..c82d4eea1 100644 --- a/pgml-cms/docs/resources/benchmarks/mindsdb-vs-postgresml.md +++ b/pgml-cms/docs/resources/benchmarks/mindsdb-vs-postgresml.md @@ -82,7 +82,7 @@ For both implementations, we can just pass in our data as part of the query for !!! code\_block time="4769.337 ms" -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I am so excited to benchmark deep learning models in SQL. I can not wait to see the results!' @@ -112,7 +112,7 @@ The first time `transform` is run with a particular model name, it will download !!! code\_block time="45.094 ms" -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'I don''t really know if 5 seconds is fast or slow for deep learning. How much time is spent downloading vs running the model?' @@ -142,7 +142,7 @@ SELECT pgml.transform( !!! code\_block time="165.036 ms" -```sql +```postgresql SELECT pgml.transform( inputs => ARRAY[ 'Are GPUs really worth it? Sometimes they are more expensive than the rest of the computer combined.' @@ -197,7 +197,7 @@ psql postgres://mindsdb:123@127.0.0.1:55432 And turn timing on to see how long it takes to run the same query: -```sql +```postgresql \timing on ``` diff --git a/pgml-cms/docs/resources/benchmarks/postgresml-is-8-40x-faster-than-python-http-microservices.md b/pgml-cms/docs/resources/benchmarks/postgresml-is-8-40x-faster-than-python-http-microservices.md index be782c0b6..c5812fd56 100644 --- a/pgml-cms/docs/resources/benchmarks/postgresml-is-8-40x-faster-than-python-http-microservices.md +++ b/pgml-cms/docs/resources/benchmarks/postgresml-is-8-40x-faster-than-python-http-microservices.md @@ -162,7 +162,7 @@ Data used for training and inference is available [here](https://static.postgres PostgresML model is trained with: -```sql +```postgresql SELECT * FROM pgml.train( project_name => 'r2', algorithm => 'xgboost', diff --git a/pgml-cms/docs/resources/data-storage-and-retrieval/README.md b/pgml-cms/docs/resources/data-storage-and-retrieval/README.md index 1ddb89b90..f3a995a4a 100644 --- a/pgml-cms/docs/resources/data-storage-and-retrieval/README.md +++ b/pgml-cms/docs/resources/data-storage-and-retrieval/README.md @@ -73,7 +73,7 @@ If you're writing your own application to ingest large amounts of data into Post Querying data stored in tables is what makes PostgresML so powerful. Postgres has one of the most comprehensive querying languages of all databases we've worked with so, for our example, we won't have any trouble calculating some statistics: -```sql +```postgresql SELECT count(*), avg("Avg. Area Income"), @@ -97,7 +97,7 @@ The SQL language is expressive and allows to select, filter and aggregate any nu Because databases store data permanently, adding more data to Postgres can be done in many ways. The simplest and most common way is to just insert it into a table you already have. Using the same example dataset, we can add a new row with just one query: -```sql +```postgresql INSERT INTO usa_house_prices ( "Avg. Area Income", "Avg. Area House Age", @@ -159,7 +159,7 @@ Looking at the USA House Prices dataset, we can find its natural key pretty easi To ensure that our table reflects this, let's add a unique index: -```sql +```postgresql CREATE UNIQUE INDEX ON usa_house_prices USING btree("Address"); ``` @@ -182,7 +182,7 @@ Once the dataset gets large enough, and we're talking millions of rows, it's no Postgres automatically uses indexes when possible and optimal to do so. From our example, if we filter the dataset by the "Address" column, Postgres will use the index we created and return a result quickly: -```sql +```postgresql SELECT "Avg. Area House Age", "Address" diff --git a/pgml-cms/docs/resources/data-storage-and-retrieval/documents.md b/pgml-cms/docs/resources/data-storage-and-retrieval/documents.md index 2182a8550..e45314c78 100644 --- a/pgml-cms/docs/resources/data-storage-and-retrieval/documents.md +++ b/pgml-cms/docs/resources/data-storage-and-retrieval/documents.md @@ -8,7 +8,7 @@ In Postgres, documents are normally stored in regular tables using the `JSONB` d If you're used to document databases like Mongo or Couch, you can replicate the same format and API in Postgres with just a single table: -```sql +```postgresql CREATE TABLE documents ( id BIGSERIAL PRIMARY KEY, document JSONB @@ -19,7 +19,7 @@ CREATE TABLE documents ( To insert a document into our table, you can just use a regular insert query: -```sql +```postgresql INSERT INTO documents ( document ) VALUES ('{"hello": "world", "values": [1, 2, 3, 4]}') @@ -32,7 +32,7 @@ This query will insert the document `{"hello": "world"}` and return its ID to th To get a document by it's ID, you can just select it from the same table, for example: -```sql +```postgresql SELECT document FROM documents WHERE id = 1; ``` @@ -52,7 +52,7 @@ The `id` column is a primary key, which gives it an index automatically. Any fet For example, if we want to fetch all documents that have a key `hello` and the value of that key `world`, we can do so: -```sql +```postgresql SELECT id, document->>'values' @@ -63,7 +63,7 @@ WHERE or if we wanted to fetch the first value inside an array stored in a `values` key, we can: -```sql +```postgresql SELECT document #>> '{values, 0}' FROM documents @@ -77,13 +77,13 @@ WHERE Most key/value databases expect its users to only use primary keys for retrieval. In the real world, things are not always that easy. Postgres makes very few assumptions about how its users interact with JSON data, and allows indexing its top level data structure for fast access: -```sql +```postgresql CREATE INDEX ON documents USING gin(document jsonb_path_ops); ``` When searching the documents for matches, Postgres will now use a much faster GIN index and give us results quickly: -```sql +```postgresql SELECT * FROM diff --git a/pgml-cms/docs/resources/data-storage-and-retrieval/partitioning.md b/pgml-cms/docs/resources/data-storage-and-retrieval/partitioning.md index 78f91279c..0e12409ed 100644 --- a/pgml-cms/docs/resources/data-storage-and-retrieval/partitioning.md +++ b/pgml-cms/docs/resources/data-storage-and-retrieval/partitioning.md @@ -26,7 +26,7 @@ In Postgres, you can create a partition by range with just a few queries. Partit Let's start with the parent table: -```sql +```postgresql CREATE TABLE energy_consumption ( "Datetime" TIMESTAMPTZ, "AEP_MW" REAL @@ -35,7 +35,7 @@ CREATE TABLE energy_consumption ( Now, let's add a couple child tables: -```sql +```postgresql CREATE TABLE energy_consumption_2004_2011 PARTITION OF energy_consumption FOR VALUES FROM ('2004-01-01') TO ('2011-12-31'); @@ -74,7 +74,7 @@ Postgres allows to query each partition individually, which is nice if we know w To make reading this data user-friendly, Postgres allows us to query the parent table instead. As long as we specify the partition key, we are guaranteed to get the most efficient query plan possible: -```sql +```postgresql SELECT avg("AEP_MW") FROM energy_consumption @@ -110,7 +110,7 @@ Partitioning by hash, unlike by range, can be applied to any data type, includin To create a table partitioned by hash, the syntax is similar to partition by range. Let's use the USA House Prices dataset we used in [Vectors](../../product/vector-database.md) and [Tabular data](README.md), and split that table into two (2) roughly equal parts. Since we already have the `usa_house_prices` table, let's create a new one with the same columns, except this one will be partitioned: -```sql +```postgresql CREATE TABLE usa_house_prices_partitioned ( "Avg. Area Income" REAL NOT NULL, "Avg. Area House Age" REAL NOT NULL, @@ -124,7 +124,7 @@ CREATE TABLE usa_house_prices_partitioned ( Let's add two (2) partitions by hash. Hashing uses modulo arithmetic; when creating a child data table with these scheme, you need to specify the denominator and the remainder: -```sql +```postgresql CREATE TABLE usa_house_prices_partitioned_1 PARTITION OF usa_house_prices_partitioned FOR VALUES WITH (modulus 2, remainder 0); @@ -136,7 +136,7 @@ FOR VALUES WITH (modulus 2, remainder 1); Importing data into the new table can be done with just one query: -```sql +```postgresql INSERT INTO usa_house_prices_partitioned SELECT * FROM usa_houses_prices; ``` @@ -196,7 +196,7 @@ unpigz amazon_reviews_with_embeddings.csv.gz Let's get started by creating a partitioned table with three (3) child partitions. We'll be using hash partitioning on the `review_body` column which should produce three (3) roughly equally sized tables. -```sql +```postgresql CREATE TABLE amazon_reviews_with_embedding ( review_body TEXT, review_embedding_e5_large VECTOR(1024) @@ -232,7 +232,7 @@ If you're doing this with `psql`, open up three (3) terminal tabs, connect to yo {% tabs %} {% tab title="Tab 1" %} -```sql +```postgresql SET maintenance_work_mem TO '2GB'; CREATE INDEX ON @@ -242,7 +242,7 @@ USING hnsw(review_embedding_e5_large vector_cosine_ops); {% endtab %} {% tab title="Tab 2" %} -```sql +```postgresql SET maintenance_work_mem TO '2GB'; CREATE INDEX ON @@ -252,7 +252,7 @@ USING hnsw(review_embedding_e5_large vector_cosine_ops); {% endtab %} {% tab title="Tab 3" %} -```sql +```postgresql SET maintenance_work_mem TO '2GB'; CREATE INDEX ON @@ -268,7 +268,7 @@ This is an example of scaling vector search using partitions. We are increasing To perform an ANN search using the indexes we created, we don't have to do anything special. Postgres will automatically scan all three (3) indexes for the closest matches and combine them into one result: -```sql +```postgresql SELECT review_body, review_embedding_e5_large <=> pgml.embed( diff --git a/pgml-cms/docs/resources/developer-docs/contributing.md b/pgml-cms/docs/resources/developer-docs/contributing.md index b5d53f55d..a739d5ac9 100644 --- a/pgml-cms/docs/resources/developer-docs/contributing.md +++ b/pgml-cms/docs/resources/developer-docs/contributing.md @@ -117,13 +117,13 @@ That's it, PostgresML is ready. You can validate the installation by running: {% tabs %} {% tab title="SQL" %} -```sql +```postgresql SELECT pgml.version(); ``` {% endtab %} {% tab title="Output" %} -```sql +```postgresql postgres=# select pgml.version(); version ------------------- @@ -135,7 +135,7 @@ postgres=# select pgml.version(); Basic extension usage: -```sql +```postgresql SELECT * FROM pgml.load_dataset('diabetes'); SELECT * FROM pgml.train('Project name', 'regression', 'pgml.diabetes', 'target', 'xgboost'); SELECT target, pgml.predict('Project name', ARRAY[age, sex, bmi, bp, s1, s2, s3, s4, s5, s6]) FROM pgml.diabetes LIMIT 10; diff --git a/pgml-cms/docs/resources/developer-docs/gpu-support.md b/pgml-cms/docs/resources/developer-docs/gpu-support.md index 0e6e86034..f9176fd17 100644 --- a/pgml-cms/docs/resources/developer-docs/gpu-support.md +++ b/pgml-cms/docs/resources/developer-docs/gpu-support.md @@ -26,7 +26,7 @@ GPU setup for XGBoost is covered in the [documentation](https://xgboost.readthed !!! example -```sql +```postgresql pgml.train( 'GPU project', algorithm => 'xgboost', @@ -42,7 +42,7 @@ GPU setup for LightGBM is covered in the [documentation](https://lightgbm.readth !!! example -```sql +```postgresql pgml.train( 'GPU project', algorithm => 'lightgbm', diff --git a/pgml-cms/docs/resources/developer-docs/self-hosting/replication.md b/pgml-cms/docs/resources/developer-docs/self-hosting/replication.md index 411ed844d..fa189e745 100644 --- a/pgml-cms/docs/resources/developer-docs/self-hosting/replication.md +++ b/pgml-cms/docs/resources/developer-docs/self-hosting/replication.md @@ -50,7 +50,7 @@ archive_command = 'pgbackrest --stanza=main archive-push %p' Postgres requires that a user with replication permissions is used for replicas to connect to the primary. To create this user, login as a superuser and run: -```sql +```postgresql CREATE ROLE replication_user PASSWORD '' LOGIN REPLICATION; ``` diff --git a/pgml-cms/docs/use-cases/README.md b/pgml-cms/docs/use-cases/README.md new file mode 100644 index 000000000..9b163e6e0 --- /dev/null +++ b/pgml-cms/docs/use-cases/README.md @@ -0,0 +1 @@ +use-cases section is deprecated, and is being refactored into guides, or a new section under product \ No newline at end of file diff --git a/pgml-cms/docs/use-cases/embeddings/README.md b/pgml-cms/docs/use-cases/embeddings/README.md index 900ae6c9f..1906c7873 100644 --- a/pgml-cms/docs/use-cases/embeddings/README.md +++ b/pgml-cms/docs/use-cases/embeddings/README.md @@ -18,7 +18,7 @@ For a deeper dive, check out the following articles we've written illustrating t ### API -```sql +```postgresql pgml.embed( transformer TEXT, -- huggingface sentence-transformer name text TEXT, -- input to embed @@ -30,13 +30,13 @@ pgml.embed( Let's use the `pgml.embed` function to generate embeddings for tweets, so we can find similar ones. We will use the `distilbert-base-uncased` model. This model is a small version of the `bert-base-uncased` model. It is a good choice for short texts like tweets. To start, we'll load a dataset that provides tweets classified into different topics. -```sql +```postgresql SELECT pgml.load_dataset('tweet_eval', 'sentiment'); ``` View some tweets and their topics. -```sql +```postgresql SELECT * FROM pgml.tweet_eval LIMIT 10; @@ -44,7 +44,7 @@ LIMIT 10; Get a preview of the embeddings for the first 10 tweets. This will also download the model and cache it for reuse, since it's the first time we've used it. -```sql +```postgresql SELECT text, pgml.embed('distilbert-base-uncased', text) FROM pgml.tweet_eval LIMIT 10; @@ -52,7 +52,7 @@ LIMIT 10; It will take a few minutes to generate the embeddings for the entire dataset. We'll save the results to a new table. -```sql +```postgresql CREATE TABLE tweet_embeddings AS SELECT text, pgml.embed('distilbert-base-uncased', text) AS embedding FROM pgml.tweet_eval; @@ -60,7 +60,7 @@ FROM pgml.tweet_eval; Now we can use the embeddings to find similar tweets. We'll use the `pgml.cosign_similarity` function to find the tweets that are most similar to a given tweet (or any other text input). -```sql +```postgresql WITH query AS ( SELECT pgml.embed('distilbert-base-uncased', 'Star Wars christmas special is on Disney') AS embedding ) @@ -75,7 +75,7 @@ On small datasets (<100k rows), a linear search that compares every row to the q * [Cube](https://www.postgresql.org/docs/current/cube.html) is a built-in extension that provides a fast indexing strategy for finding similar vectors. By default it has an arbitrary limit of 100 dimensions, unless Postgres is compiled with a larger size. * [PgVector](https://github.com/pgvector/pgvector) supports embeddings up to 2000 dimensions out of the box, and provides a fast indexing strategy for finding similar vectors. -```sql +```postgresql CREATE EXTENSION vector; CREATE TABLE items (text TEXT, embedding VECTOR(768)); INSERT INTO items SELECT text, embedding FROM tweet_embeddings; diff --git a/pgml-cms/docs/use-cases/embeddings/generating-llm-embeddings-with-open-source-models-in-postgresml.md b/pgml-cms/docs/use-cases/embeddings/generating-llm-embeddings-with-open-source-models-in-postgresml.md index 396301e59..e69de29bb 100644 --- a/pgml-cms/docs/use-cases/embeddings/generating-llm-embeddings-with-open-source-models-in-postgresml.md +++ b/pgml-cms/docs/use-cases/embeddings/generating-llm-embeddings-with-open-source-models-in-postgresml.md @@ -1,343 +0,0 @@ -# Generating LLM embeddings with open source models - -PostgresML makes it easy to generate embeddings from text in your database using a large selection of state-of-the-art models with one simple call to **`pgml.embed`**`(model_name, text)`. Prove the results in this series to your own satisfaction, for free, by signing up for a GPU accelerated database. - -This article is the first in a multipart series that will show you how to build a post-modern semantic search and recommendation engine, including personalization, using open source models. - -1. Generating LLM Embeddings with HuggingFace models -2. Tuning vector recall with pgvector -3. Personalizing embedding results with application data -4. Optimizing semantic results with an XGBoost ranking model - coming soon! - -## Introduction - -In recent years, embeddings have become an increasingly popular technique in machine learning and data analysis. They are essentially vector representations of data points that capture their underlying characteristics or features. In most programming environments, vectors can be efficiently represented as native array datatypes. They can be used for a wide range of applications, from natural language processing to image recognition and recommendation systems. - -They can also turn natural language into quantitative features for downstream machine learning models and applications. - -_Embeddings show us the relationships between rows in the database._ - -A popular use case driving the adoption of "vector databases" is doing similarity search on embeddings, often referred to as "Semantic Search". This is a powerful technique that allows you to find similar items in large datasets by comparing their vectors. For example, you could use it to find similar products in an e-commerce site, similar songs in a music streaming service, or similar documents given a text query. - -Postgres is a good candidate for this type of application because it's a general purpose database that can store both the embeddings and the metadata in the same place, and has a rich set of features for querying and analyzing them, including fast vector indexes used for search. - -This chapter is the first in a multipart series that will show you how to build a modern semantic search and recommendation engine, including personalization, using PostgresML and open source models. We'll show you how to use the **`pgml.embed`** function to generate embeddings from text in your database using an open source pretrained model. Further chapters will expand on how to implement many of the different use cases for embeddings in Postgres, like similarity search, personalization, recommendations and fine-tuned models. - -## It always starts with data - -Most general purpose databases are full of all sorts of great data for machine learning use cases. Text data has historically been more difficult to deal with using complex Natural Language Processing techniques, but embeddings created from open source models can effectively turn unstructured text into structured features, perfect for more straightforward implementations. - -In this example, we'll demonstrate how to generate embeddings for products on an e-commerce site. We'll use a public dataset of millions of product reviews from the [Amazon US Reviews](https://huggingface.co/datasets/amazon\_us\_reviews). It includes the product title, a text review written by a customer and some additional metadata about the product, like category. With just a few pieces of data, we can create a full-featured and personalized product search and recommendation engine, using both generic embeddings and later, additional fine-tuned models trained with PostgresML. - -PostgresML includes a convenience function for loading public datasets from [HuggingFace](https://huggingface.co/datasets) directly into your database. To load the DVD subset of the Amazon US Reviews dataset into your database, run the following command: - -!!! code\_block - -```postgresql -SELECT * -FROM pgml.load_dataset('amazon_us_reviews', 'Video_DVD_v1_00'); -``` - -!!! - -It took about 23 minutes to download the 7.1GB raw dataset with 5,069,140 rows into a table within the `pgml` schema (where all PostgresML functionality is name-spaced). Once it's done, you can see the table structure with the following command: - -!!! generic - -!!! code\_block - -```postgresql -\d pgml.amazon_us_reviews -``` - -!!! - -!!! results - -| Column | Type | Collation | Nullable | Default | -| ------------------ | ------- | --------- | -------- | ------- | -| marketplace | text | | | | -| customer\_id | text | | | | -| review\_id | text | | | | -| product\_id | text | | | | -| product\_parent | text | | | | -| product\_title | text | | | | -| product\_category | text | | | | -| star\_rating | integer | | | | -| helpful\_votes | integer | | | | -| total\_votes | integer | | | | -| vine | bigint | | | | -| verified\_purchase | bigint | | | | -| review\_headline | text | | | | -| review\_body | text | | | | -| review\_date | text | | | | - -!!! - -!!! - -Let's take a peek at the first 5 rows of data: - -!!! code\_block - -```postgresql -SELECT * -FROM pgml.amazon_us_reviews -LIMIT 5; -``` - -!!! results - -| marketplace | customer\_id | review\_id | product\_id | product\_parent | product\_title | product\_category | star\_rating | helpful\_votes | total\_votes | vine | verified\_purchase | review\_headline | review\_body | review\_date | -| ----------- | ------------ | -------------- | ----------- | --------------- | ------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------ | -------------- | ------------ | ---- | ------------------ | --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ | -| US | 27288431 | R33UPQQUZQEM8 | B005T4ND06 | 400024643 | Yoga for Movement Disorders DVD: Rebuilding Strength, Balance, and Flexibility for Parkinson's Disease and Dystonia | Video DVD | 5 | 3 | 3 | 0 | 1 | This was a gift for my aunt who has Parkinson's ... | This was a gift for my aunt who has Parkinson's. While I have not previewed it myself, I also have not gotten any complaints. My prior experiences with yoga tell me this should be just what the doctor ordered. | 2015-08-31 | -| US | 13722556 | R3IKTNQQPD9662 | B004EPZ070 | 685335564 | Something Borrowed | Video DVD | 5 | 0 | 0 | 0 | 1 | Five Stars | Teats my heart out. | 2015-08-31 | -| US | 20381037 | R3U27V5QMCP27T | B005S9EKCW | 922008804 | Les Miserables (2012) \[Blu-ray] | Video DVD | 5 | 1 | 1 | 0 | 1 | Great movie! | Great movie. | 2015-08-31 | -| US | 24852644 | R2TOH2QKNK4IOC | B00FC1ZCB4 | 326560548 | Alien Anthology and Prometheus Bundle \[Blu-ray] | Video DVD | 5 | 0 | 1 | 0 | 1 | Amazing | My husband was so excited to receive these as a gift! Great picture quality and great value! | 2015-08-31 | -| US | 15556113 | R2XQG5NJ59UFMY | B002ZG98Z0 | 637495038 | Sex and the City 2 | Video DVD | 5 | 0 | 0 | 0 | 1 | Five Stars | Love this series. | 2015-08-31 | - -!!! - -!!! - -## Generating embeddings from natural language text - -PostgresML provides a simple interface to generate embeddings from text in your database. You can use the [`pgml.embed`](https://postgresml.org/docs/transformers/embeddings) function to generate embeddings for a column of text. The function takes a transformer name and a text value. The transformer will automatically be downloaded and cached on your connection process for reuse. You can see a list of potential good candidate models to generate embeddings on the [Massive Text Embedding Benchmark leaderboard](https://huggingface.co/spaces/mteb/leaderboard). - -Since our corpus of documents (movie reviews) are all relatively short and similar in style, we don't need a large model. [`intfloat/e5-small`](https://huggingface.co/intfloat/e5-small) will be a good first attempt. The great thing about PostgresML is you can always regenerate your embeddings later to experiment with different embedding models. - -It takes a couple of minutes to download and cache the `intfloat/e5-small` model to generate the first embedding. After that, it's pretty fast. - -Note how we prefix the text we want to embed with either `passage:` or `query:` , the e5 model requires us to prefix our data with `passage:` if we're generating embeddings for our corpus and `query:` if we want to find semantically similar content. - -```postgresql -SELECT pgml.embed('intfloat/e5-small', 'passage: hi mom'); -``` - -This is a pretty powerful function, because we can pass any arbitrary text to any open source model, and it will generate an embedding for us. We can benchmark how long it takes to generate an embedding for a single review, using client-side timings in Postgres: - -```postgresql -\timing on -``` - -Aside from using this function with strings passed from a client, we can use it on strings already present in our database tables by calling **pgml.embed** on columns. For example, we can generate an embedding for the first review using a pretty simple query: - -!!! generic - -!!! code\_block time="54.820 ms" - -```postgresql -SELECT - review_body, - pgml.embed('intfloat/e5-small', 'passage: ' || review_body) -FROM pgml.amazon_us_reviews -LIMIT 1; -``` - -!!! - -!!! results - -``` -CREATE INDEX -``` - -!!! - -!!! - -Time to generate an embedding increases with the length of the input text, and varies widely between different models. If we up our batch size (controlled by `LIMIT`), we can see the average time to compute an embedding on the first 1000 reviews is about 17ms per review: - -!!! code\_block time="17955.026 ms" - -```postgresql -SELECT - review_body, - pgml.embed('intfloat/e5-small', 'passage: ' || review_body) AS embedding -FROM pgml.amazon_us_reviews -LIMIT 1000; -``` - -!!! - -## Comparing different models and hardware performance - -This database is using a single GPU with 32GB RAM and 8 vCPUs with 16GB RAM. Running these benchmarks while looking at the database processes with `htop` and `nvidia-smi`, it becomes clear that the bottleneck in this case is actually tokenizing the strings which happens in a single thread on the CPU, not computing the embeddings on the GPU which was only 20% utilized during the query. - -We can also do a quick sanity check to make sure we're really getting value out of our GPU by passing the device to our embedding function: - -!!! code\_block time="30421.491 ms" - -```postgresql -SELECT - reviqew_body, - pgml.embed( - 'intfloat/e5-small', - 'passage: ' || review_body, - '{"device": "cpu"}' - ) AS embedding -FROM pgml.amazon_us_reviews -LIMIT 1000; -``` - -!!! - -Forcing the embedding function to use `cpu` is almost 2x slower than `cuda` which is the default when GPUs are available. - -If you're managing dedicated hardware, there's always a decision to be made about resource utilization. If this is a multi-workload database with other queries using the GPU, it's probably great that we're not completely hogging it with our multi-decade-Amazon-scale data import process, but if this is a machine we've spun up just for this task, we can up the resource utilization to 4 concurrent connections, all running on a subset of the data to more completely utilize our CPU, GPU and RAM. - -Another consideration is that GPUs are much more expensive right now than CPUs, and if we're primarily interested in backfilling a dataset like this, high concurrency across many CPU cores might just be the price-competitive winner. - -With 4x concurrency and a GPU, it'll take about 6 hours to compute all 5 million embeddings, which will cost $72 on PostgresML Cloud. If we use the CPU instead of the GPU, we'll probably want more cores and higher concurrency to plug through the job faster. A 96 CPU core machine could complete the job in half the time our single GPU would take and at a lower hourly cost as well, for a total cost of $24. It's overall more cost-effective and faster in parallel, but keep in mind if you're interactively generating embeddings for a user facing application, it will add double the latency, 30ms CPU vs 17ms for GPU. - -For comparison, it would cost about $299 to use OpenAI's cheapest embedding model to process this dataset. Their API calls average about 300ms, although they have high variability (200-400ms) and greater than 1000ms p99 in our measurements. They also have a default rate limit of 200 tokens per minute which means it would take 1,425 years to process this dataset. You better call ahead. - -| Processor | Latency | Cost | Time | -| --------- | ------- | ---- | --------- | -| CPU | 30ms | $24 | 3 hours | -| GPU | 17ms | $72 | 6 hours | -| OpenAI | 300ms | $299 | millennia | - -You can also find embedding models that outperform OpenAI's `text-embedding-ada-002` model across many different tests on the [leaderboard](https://huggingface.co/spaces/mteb/leaderboard). It's always best to do your own benchmarking with your data, models, and hardware to find the best fit for your use case. - -> _HTTP requests to a different datacenter cost more time and money for lower reliability than co-located compute and storage._ - -## Instructor embedding models - -The current leading model is `hkunlp/instructor-xl`. Instructor models take an additional `instruction` parameter which includes context for the embeddings use case, similar to prompts before text generation tasks. - -Instructions can provide a "classification" or "topic" for the text: - -#### Classification - -!!! code\_block time="17.912ms" - -```postgresql -SELECT pgml.embed( - transformer => 'hkunlp/instructor-xl', - text => 'The Federal Reserve on Wednesday raised its benchmark interest rate.', - kwargs => '{"instruction": "Represent the Financial statement:"}' -); -``` - -!!! - -They can also specify particular use cases for the embedding: - -#### Querying - -!!! code\_block time="24.263 ms" - -```postgresql -SELECT pgml.embed( - transformer => 'hkunlp/instructor-xl', - text => 'where is the food stored in a yam plant', - kwargs => '{ - "instruction": "Represent the Wikipedia question for retrieving supporting documents:" - }' -); -``` - -!!! - -#### Indexing - -!!! code\_block time="30.571 ms" - -```postgresql -SELECT pgml.embed( - transformer => 'hkunlp/instructor-xl', - text => 'Disparate impact in United States labor law refers to practices in employment, housing, and other areas that adversely affect one group of people of a protected characteristic more than another, even though rules applied by employers or landlords are formally neutral. Although the protected classes vary by statute, most federal civil rights laws protect based on race, color, religion, national origin, and sex as protected traits, and some laws include disability status and other traits as well.', - kwargs => '{"instruction": "Represent the Wikipedia document for retrieval:"}' -); -``` - -!!! - -#### Clustering - -!!! code\_block time="18.986 ms" - -```postgresql -SELECT pgml.embed( - transformer => 'hkunlp/instructor-xl', - text => 'Dynamical Scalar Degree of Freedom in Horava-Lifshitz Gravity"}', - kwargs => '{"instruction": "Represent the Medicine sentence for clustering:"}' -); -``` - -!!! - -Performance remains relatively good, even with the most advanced models. - -## Generating embeddings for a large dataset - -For our use case, we want to generate an embedding for every single review in the dataset. We'll use the `vector` datatype available from the `pgvector` extension to store (and later index) embeddings efficiently. All PostgresML cloud installations include [pgvector](https://github.com/pgvector/pgvector). To enable this extension in your database, you can run: - -```postgresql -CREATE EXTENSION vector; -``` - -Then we can add a `vector` column for our review embeddings, with 384 dimensions (the size of e5-small embeddings): - -```postgresql -ALTER TABLE pgml.amazon_us_reviews -ADD COLUMN review_embedding_e5_large vector(1024); -``` - -It's best practice to keep running queries on a production database relatively short, so rather than trying to update all 5M rows in one multi-hour query, we should write a function to issue the updates in smaller batches. To make iterating over the rows easier and more efficient, we'll add an `id` column with an index to our table: - -```postgresql -ALTER TABLE pgml.amazon_us_reviews -ADD COLUMN id SERIAL PRIMARY KEY; -``` - -Every language/framework/codebase has its own preferred method for backfilling data in a table. The 2 most important considerations are: - -1. Keep the number of rows per query small enough that the queries take less than a second -2. More concurrency will get the job done faster, but keep in mind the other workloads on your database - -Here's an example of a very simple back-fill job implemented in pure PGSQL, but I'd also love to see example PRs opened with your techniques in your language of choice for tasks like this. - -```postgresql -DO $$ -BEGIN - FOR i in 1..(SELECT max(id) FROM pgml.amazon_us_reviews) by 10 LOOP - BEGIN RAISE NOTICE 'updating % to %', i, i + 10; END; - - UPDATE pgml.amazon_us_reviews - SET review_embedding_e5_large = pgml.embed( - 'intfloat/e5-large', - 'passage: ' || review_body - ) - WHERE id BETWEEN i AND i + 10 - AND review_embedding_e5_large IS NULL; - - COMMIT; - END LOOP; -END; -$$; -``` - -## What's next? - -That's it for now. We've got an Amazon scale table with state-of-the-art machine learning embeddings. As a premature optimization, we'll go ahead and build an index on our new column to make our future vector similarity queries faster. For the full documentation on vector indexes in Postgres see the [pgvector docs](https://github.com/pgvector/pgvector). - -!!! code\_block time="4068909.269 ms (01:07:48.909)" - -```postgresql -CREATE INDEX CONCURRENTLY index_amazon_us_reviews_on_review_embedding_e5_large -ON pgml.amazon_us_reviews -USING ivfflat (review_embedding_e5_large vector_cosine_ops) -WITH (lists = 2000); -``` - -!!! - -!!! tip - -Create indexes `CONCURRENTLY` to avoid locking your table for other queries. - -!!! - -Building a vector index on a table with this many entries takes a while, so this is a good time to take a coffee break. In the next article we'll look at how to query these embeddings to find the best products and make personalized recommendations for users. We'll also cover updating an index in real time as new data comes in. diff --git a/pgml-cms/docs/use-cases/fraud-detection.md b/pgml-cms/docs/use-cases/fraud-detection.md deleted file mode 100644 index dbe05b5dd..000000000 --- a/pgml-cms/docs/use-cases/fraud-detection.md +++ /dev/null @@ -1,3 +0,0 @@ -# Fraud Detection - -Describe this app, write a GitHub issue and ask people to do a :thumbsup:on the issue diff --git a/pgml-cms/docs/use-cases/recommendation-engine.md b/pgml-cms/docs/use-cases/recommendation-engine.md deleted file mode 100644 index 73e132a6e..000000000 --- a/pgml-cms/docs/use-cases/recommendation-engine.md +++ /dev/null @@ -1,3 +0,0 @@ -# Recommendation Engine - -Describe this app, write a GitHub issue and ask people to do a :thumbsup:on the issue diff --git a/pgml-cms/docs/use-cases/test-hello.md b/pgml-cms/docs/use-cases/test-hello.md deleted file mode 100644 index 18f2549a5..000000000 --- a/pgml-cms/docs/use-cases/test-hello.md +++ /dev/null @@ -1 +0,0 @@ -# Test hekki diff --git a/pgml-cms/docs/use-cases/time-series-forecasting.md b/pgml-cms/docs/use-cases/time-series-forecasting.md deleted file mode 100644 index a7f7ab998..000000000 --- a/pgml-cms/docs/use-cases/time-series-forecasting.md +++ /dev/null @@ -1,2 +0,0 @@ -# Time-series Forecasting - diff --git a/pgml-dashboard/src/components/navigation/left_nav/docs/template.html b/pgml-dashboard/src/components/navigation/left_nav/docs/template.html index 15390a368..06459e291 100644 --- a/pgml-dashboard/src/components/navigation/left_nav/docs/template.html +++ b/pgml-dashboard/src/components/navigation/left_nav/docs/template.html @@ -3,7 +3,7 @@ match title.to_lowercase().as_str() { "api" => "sdk", "product" => "dashboard", - "use cases" => "account_circle", + "guides" => "menu_book", "resources" => "school", "introduction" => "list_alt", _ => "dashboard", diff --git a/pgml-dashboard/src/utils/markdown.rs b/pgml-dashboard/src/utils/markdown.rs index 84f9243bf..4cb4b136c 100644 --- a/pgml-dashboard/src/utils/markdown.rs +++ b/pgml-dashboard/src/utils/markdown.rs @@ -262,8 +262,6 @@ impl SyntaxHighlighterAdapter for SyntaxHighlighter { fn build_pre_tag(&self, _attributes: &HashMap) -> String { String::from("

                 copy#codeCopy\" class=\"material-symbols-outlined btn-code-toolbar\">content_copy
-                link
-                edit
             
")
     }
 
diff --git a/pgml-dashboard/static/css/scss/base/_base.scss b/pgml-dashboard/static/css/scss/base/_base.scss
index c6cc402b1..80ca64b33 100644
--- a/pgml-dashboard/static/css/scss/base/_base.scss
+++ b/pgml-dashboard/static/css/scss/base/_base.scss
@@ -41,10 +41,6 @@ pre {
     }
 }
 
-pre[data-controller="copy"] {
-    padding-top: 2rem;
-}
-
 // links
 a {
     text-decoration: none; 
diff --git a/pgml-dashboard/static/css/scss/components/_admonitions.scss b/pgml-dashboard/static/css/scss/components/_admonitions.scss
index 6e3dde527..ed9e13153 100644
--- a/pgml-dashboard/static/css/scss/components/_admonitions.scss
+++ b/pgml-dashboard/static/css/scss/components/_admonitions.scss
@@ -69,9 +69,6 @@
     pre {
         margin: 0px;
     }
-    pre[data-controller="copy"] {
-        padding-top: 2rem !important;
-    }
 
     div.code-block {
         border: none !important;
@@ -84,7 +81,6 @@
 
     .execution-time {
         border-top: 2px solid #{$gray-100};
-        border-bottom: 2px solid #{$gray-100};
         background-color: #{$gray-600};
         padding: 12px 12px;
         margin: 0px !important;
diff --git a/pgml-dashboard/static/css/scss/components/_code.scss b/pgml-dashboard/static/css/scss/components/_code.scss
index f7c97f2a0..a9973069b 100644
--- a/pgml-dashboard/static/css/scss/components/_code.scss
+++ b/pgml-dashboard/static/css/scss/components/_code.scss
@@ -143,7 +143,7 @@ pre {
         pre {
             background-color: #{$gray-500};
             code {
-                background-color: #{$gray-500};
+                background-color: #{$gray-600};
             }
         }
 
@@ -222,6 +222,7 @@ pre {
     pre {
         background-color: #{$gray-600};
         border-radius: #{$border-radius};
+        border: solid 2px white;
 
         code {
             border: none;
diff --git a/pgml-dashboard/static/css/scss/pages/_docs.scss b/pgml-dashboard/static/css/scss/pages/_docs.scss
index 2bf785658..f7a68650e 100644
--- a/pgml-dashboard/static/css/scss/pages/_docs.scss
+++ b/pgml-dashboard/static/css/scss/pages/_docs.scss
@@ -3,16 +3,36 @@
 
     div.results {
         overflow-x: auto;
-        margin: 24px 24px;
+        margin: 0;
+        padding: 0;
+        border-top: 2px solid white;
 
         .code-toolbar {
-            display: none;
+            display: none !important;
         }
 
         pre {
-            background-color: #{$gray-500};
-            code {
-                background-color: #{$gray-500};
+            padding: 0 !important;
+            border: none;
+            margin: 0;
+        }
+
+        .overflow-auto {
+            margin: 0;
+        }
+
+        table {
+            margin: 0;
+            border-spacing: 0;
+            background-color: #{$gray-900};
+
+            tr {
+                padding: 0 0.5rem;
+            }
+
+            td, th {
+                border: 1px solid #{$gray-800};
+                padding: 0.1rem 0.5rem;
             }
         }
 
@@ -32,13 +52,15 @@
                 border-start-end-radius: 0px;
             }
         }
+
+        > * {
+            margin: 0.5rem 1rem;
+        }
     }
 
     div.code-block {
         overflow-x: auto;
-        border: 2px solid $slate-tint-1000;
-        border-radius: 8px;
-        margin: 24px 0px;
+        border-bottom: 2px solid white;
 
         .title {
             background-color: #{$gray-700};
@@ -50,6 +72,8 @@
 
         pre {
             margin: 0px;
+            border: none;
+            padding: 0px !important;
         }
 
         &.with-title {
@@ -106,10 +130,41 @@
     pre {
         background-color: #{$gray-600};
         border-radius: #{$border-radius};
+        padding: 0;
+        position: relative;
 
         code {
             border: none;
             white-space: inherit;
+            padding: 0;
+        }
+
+        .code-toolbar {
+            display: none;
+            z-index: 1;
+            border: 2px solid white;
+            border-bottom-left-radius: 8px;
+            border-top-right-radius: 8px;
+            right: -2px;
+            top: -2px;
+        }
+
+        .cm-gutters {
+            background: $gray-800;
+        }
+
+        .cm-activeLineGutter {
+            background: $gray-800;
+        }
+
+        .cm-content {
+            padding: 0.75rem;
+        }
+    }
+
+    pre:hover {
+        .code-toolbar {
+            display: flex;
         }
     }
 
@@ -186,15 +241,11 @@
     // Codemirror overrideds
     .cm-editor {
         background: inherit;
-
-        // default no line numbers. 
-        .cm-gutters {
-            display: none;
-        }
     }
 
     .cm-gutters {
         background: inherit;
+        border-right: 1px solid #{$white};
     }
     
     .code-highlight {
diff --git a/pgml-dashboard/static/images/gym/quick_start.md b/pgml-dashboard/static/images/gym/quick_start.md
index 3662b0c45..026d8ddf8 100644
--- a/pgml-dashboard/static/images/gym/quick_start.md
+++ b/pgml-dashboard/static/images/gym/quick_start.md
@@ -25,7 +25,7 @@ Once you have your PostgresML instance running, we'll be ready to get started.
 
 The first part of machine learning is getting your data in a format you can use. That's usually the hardest part, but thankfully we have a few example datasets we can use. To load one of them, navigate to the IDE tab and run this query:
 
-```sql
+```postgresql
 SELECT * FROM pgml.load_dataset('diabetes');
 ```
 
@@ -46,7 +46,7 @@ To load them into PostgresML, use the same function above with the desired datas
 The SQL editor you just used can run arbitrary queries on the PostgresML instance. For example,
 if we want to see what dataset we just loaded looks like, we can run:
 
-```sql
+```postgresql
 SELECT * FROM pgml.diabetes LIMIT 5;
 ```
 
@@ -78,7 +78,7 @@ PostgresML organizes itself into projects. A project is just a name for model(s)
 
 Using the IDE, run:
 
-```sql
+```postgresql
 SELECT * FROM pgml.train(
 	'My First Project',
 	task => 'regression',
@@ -106,7 +106,7 @@ Inference is the act of predicting labels that we haven't necessarily used in tr
 
 Let's try and predict some new values. Using the IDE, run:
 
-```sql
+```postgresql
 SELECT pgml.predict(
 	'My First Project',
 	ARRAY[
@@ -130,7 +130,7 @@ You should see something like this:
 
 The `prediction` column represents the possible value of the `target` column given the new features we just passed into the `pgml.predict()` function. You can just as easily predict multiple points and compare them to the actual labels in the dataset:
 
-```sql
+```postgresql
 SELECT
 	pgml.predict('My First Project 2', ARRAY[
 		age, sex, bmi, bp, s1, s3, s3, s4, s5, s6
@@ -151,7 +151,7 @@ As you can see, we automatically performed some analysis on the data. Visualizin
 
 XGBoost is a good algorithm, but what if there are better ones? Let's try training a few more using the IDE. Run these one at a time:
 
-```sql
+```postgresql
 -- Simple linear regression.
 SELECT * FROM pgml.train(
 	'My First Project',
diff --git a/pgml-extension/examples/regression.sql b/pgml-extension/examples/regression.sql
index e355b6393..dfc469165 100644
--- a/pgml-extension/examples/regression.sql
+++ b/pgml-extension/examples/regression.sql
@@ -81,7 +81,7 @@ SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'random_forest', h
 -- gradient boosting
 SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'xgboost', hyperparams => '{"n_estimators": 10}');
 SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'catboost', hyperparams => '{"n_estimators": 10}');
---SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'xgboost_random_forest', hyperparams => '{"n_estimators": 10}');
+-- SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'xgboost_random_forest', hyperparams => '{"n_estimators": 10}');
 -- SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'lightgbm', hyperparams => '{"n_estimators": 1}');
 -- Histogram Gradient Boosting is too expensive for normal tests on even a toy dataset
 -- SELECT * FROM pgml.train('Diabetes Progression', algorithm => 'hist_gradient_boosting', hyperparams => '{"max_iter": 10}');
diff --git a/pgml-extension/requirements.txt b/pgml-extension/requirements.txt
index 7ec447bc8..8cc64677e 100644
--- a/pgml-extension/requirements.txt
+++ b/pgml-extension/requirements.txt
@@ -45,6 +45,8 @@ sentence-transformers
 rouge
 sacrebleu
 sacremoses
+evaluate
+trl
 
 # Utils
 datasets
diff --git a/pgml-extension/src/api.rs b/pgml-extension/src/api.rs
index 623d8f872..14efde32b 100644
--- a/pgml-extension/src/api.rs
+++ b/pgml-extension/src/api.rs
@@ -619,7 +619,7 @@ pub fn embed_batch(
 /// Returns `true` if the GPU cache was successfully cleared, `false` otherwise.
 /// # Example
 ///
-/// ```sql
+/// ```postgresql
 /// SELECT pgml.clear_gpu_cache(memory_usage => 0.5);
 /// ```
 #[cfg(all(feature = "python", not(feature = "use_as_lib")))]