nomic 3.0.32__tar.gz → 3.8.0__tar.gz

nomic-3.8.0/MANIFEST.in

@@ -0,0 +1 @@
+include nomic/py.typed

nomic-3.8.0/PKG-INFO

@@ -0,0 +1,247 @@
+Metadata-Version: 2.1
+Name: nomic
+Version: 3.8.0
+Summary: The official Nomic python client.
+Home-page: https://github.com/nomic-ai/nomic
+Author: nomic.ai
+Author-email: support@nomic.ai
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+Provides-Extra: local
+Provides-Extra: aws
+Provides-Extra: all
+Provides-Extra: dev
+
+<h1 align="center">Nomic Atlas Python Client</h1>
+<h3 align="center">Explore, label, search and share massive datasets in your web browser.</h3>
+<p>This repository contains Python bindings for working with <a href="https://atlas.nomic.ai/">Nomic Atlas</a>, the world’s most powerful unstructured data interaction platform. Atlas supports datasets from hundreds to tens of millions of points, and supports data modalities ranging from text to image to audio to video. </p>
+
+With Nomic Atlas, you can:
+
+- Generate, store and retrieve embeddings for your unstructured data.
+- Find insights in your unstructured data and embeddings all from your web browser.
+- Share and present your datasets and data findings to anyone.
+
+### Where to find us?
+
+[https://atlas.nomic.ai/](https://atlas.nomic.ai/)
+
+
+
+## Table of Contents
+
+- [Quick resources](#quick-resources)
+  - [Example maps](#example-maps)
+- [Features](#features)
+- [Quickstart](#quickstart)
+  - [Installation](#installation)
+  - [Make your first map](#make-your-first-map)
+- [Atlas usage examples](#atlas-usage-examples)
+  - [Access your embeddings](#access-your-embeddings)
+  - [View your data's topic model](#view-your-datas-topic-model)
+  - [Search for data semantically](#search-for-data-semantically)
+- [Documentation](#documentation)
+- [Discussion](#discussion)
+- [Community](#community)
+
+## Quick Resources
+
+<p >
+  Try the <a href="https://colab.research.google.com/drive/1CZBo3LV0FoRTVRN3v068tvNJgbeWpcSX?usp=sharing">:notebook: Colab Demo</a> to get started in Python
+</p>
+
+<p>
+  Read the <a href="https://docs.nomic.ai">:closed_book:	 Atlas Docs</a>
+</p>
+
+<p>
+  Join our <a href="https://discord.gg/myY5YDR8z8">:hut: Discord</a> to start chatting and get help
+</p>
+
+#### Example maps
+
+<a href="https://atlas.nomic.ai/map/twitter">:world_map: Map of Twitter</a> (5.4 million tweets)
+<br> <br>
+<a href="https://atlas.nomic.ai/map/stablediffusion">:world_map: Map of StableDiffusion Generations</a> (6.4 million images)
+<br> <br>
+<a href="https://atlas.nomic.ai/map/neurips">:world_map: Map of NeurIPS Proceedings</a> (16,623 abstracts)
+
+</p>
+
+## Features
+
+Here are just a few of the features which Atlas offers:
+
+- Organize your **text, image, and embedding data**
+- Create **beautiful and shareable** maps **with or without coding knowledge**
+- Have easy access to both **high-level data structures** and **individual datapoints**
+- **Search** millions of datapoints **instantly**
+- **Cluster data** into semantic topics
+- **Tag and clean** your dataset
+- **Deduplicate** text, images, video, audio
+
+
+
+## Quickstart
+
+### Installation
+
+1. Install the Nomic library
+
+```bash
+pip install nomic
+```
+
+2. Login or create your Nomic account:
+
+```bash
+nomic login
+```
+
+3. Follow the instructions to obtain your access token.
+
+```bash
+nomic login [token]
+```
+
+### Make your first map
+
+```python
+from nomic import atlas
+import numpy as np
+
+# Randomly generate a set of 10,000 high-dimensional embeddings
+num_embeddings = 10000
+embeddings = np.random.rand(num_embeddings, 256)
+
+# Create Atlas project
+dataset = atlas.map_data(embeddings=embeddings)
+
+print(dataset)
+```
+
+## Atlas usage examples
+
+### Access your embeddings
+
+Atlas stores, manages and generates embeddings for your unstructured data.
+
+You can access Atlas latent embeddings (e.g. high dimensional) or the two-dimensional embeddings generated for web display.
+
+```python
+# Access your Atlas map and download your embeddings
+map = dataset.maps[0]
+
+projected_embeddings = map.embeddings.projected
+latent_embeddings = map.embeddings.latent
+```
+
+```python
+print(projected_embeddings)
+```
+
+```
+# Response:
+id 	x 	y
+0 	9.815330 	-8.105308
+1 	-8.725819 	5.980628
+2 	13.199472 	-1.103389
+... 	... 	... 	...
+```
+
+```python
+print(latent_embeddings)
+```
+
+```
+# Response:
+n x d numpy.ndarray where n = number of datapoints and d = number of latent dimensions
+```
+
+### View your data’s topic model
+
+Atlas automatically organizes your data into topics informed by the latent contents of your embeddings. Visually, these are represented by regions of homogenous color on an Atlas map.
+
+You can access and operate on topics programmatically by using the `topics` attribute
+of an AtlasMap.
+
+```python
+# Access your Atlas map
+map = dataset.maps[0]
+
+# Access a pandas DataFrame associating each datum on your map to their topics at each topic depth.
+topic_df = map.topics.df
+
+print(map.topics.df)
+
+```
+
+```
+Response:
+
+id topic_depth_1 topic_depth_2
+0 Oil Prices mergers and acquisitions
+1 Iraq War Trial of Thatcher
+2 Oil Prices Economic Growth
+... ... ... ...
+9997 Oil Prices Economic Growth
+9998 Baseball Giambi's contract
+9999 Olympic Gold Medal European Football
+
+```
+
+### Search for data semantically
+
+Use Atlas to automatically find nearest neighbors in your vector database.
+
+```python
+# Load map and perform vector search for the five nearest neighbors of datum with id "my_query_point"
+map = dataset.maps[0]
+
+with dataset.wait_for_dataset_lock():
+  neighbors, _ = map.embeddings.vector_search(ids=['my_query_point'], k=5)
+
+# Return similar data points
+similar_datapoints = dataset.get_data(ids=neighbors[0])
+
+print(similar_datapoints)
+```
+
+```
+Response:
+
+Original query point:
+"Intel abandons digital TV chip project NEW YORK, October 22 (newratings.com) - Global semiconductor giant Intel Corporation (INTC.NAS) has called off its plan to develop a new chip for the digital projection televisions."
+
+Nearest neighbors:
+"Intel awaits government move on expensing options Figuring it's had enough of fighting over options, the chip giant is waiting to see what Congress comes up with."
+"Citigroup Takes On Intel The financial services giant takes over non-memory semiconductor chip production."
+"Intel Seen Readying New Wi-Fi Chips  SAN FRANCISCO (Reuters) - Intel Corp. this week is  expected to introduce a chip that adds support for a relatively  obscure version of Wi-Fi, analysts said on Monday, in a move  that could help ease congestion on wireless networks."
+"Intel pledges to bring Itanic down to Xeon price-point EM64T a stand-in until the real anti-AMD64 kit arrives"
+```
+
+## Background
+
+Atlas is developed by the [Nomic AI](https://home.nomic.ai/) team, which is based in NYC. Nomic also developed and maintains [GPT4All](https://gpt4all.io/index.html), an open-source LLM chatbot ecosystem.
+
+## Discussion
+
+Join the discussion on our [:hut: Discord](https://discord.gg/myY5YDR8z8) to ask questions, get help, and chat with others about Atlas, Nomic, GPT4All, and related topics. Our doors are open to enthusiasts of all skill levels.
+
+## Community
+
+- Blog: [https://blog.nomic.ai/](https://blog.nomic.ai/)
+- Twitter: [https://twitter.com/nomic_ai](https://twitter.com/nomic_ai)
+- Nomic Website: [https://home.nomic.ai/](https://home.nomic.ai/)
+- Atlas Website: [https://atlas.nomic.ai/](https://atlas.nomic.ai/)
+- GPT4All Website: [https://gpt4all.io/index.html](https://gpt4all.io/index.html)
+- LinkedIn: [https://www.linkedin.com/company/nomic-ai](https://www.linkedin.com/company/nomic-ai)
+
+<br>
+
+[Go to top](#)
+
+

nomic-3.8.0/nomic/__init__.py

@@ -0,0 +1,10 @@
+from .cli import login
+from .client import NomicClient
+from .dataset import AtlasDataset, AtlasUser
+
+__all__ = [
+    "AtlasDataset",
+    "AtlasUser",
+    "NomicClient",
+    "login",
+]

{nomic-3.0.32 → nomic-3.8.0}/nomic/atlas.py

@@ -3,17 +3,17 @@ This class allows for programmatic interactions with Atlas - Nomic's neural data
 or in a Jupyter Notebook to organize and interact with your unstructured data.
 """
 
-import uuid
 from typing import Dict, Iterable, List, Optional, Union
 
 import numpy as np
 import pyarrow as pa
 from loguru import logger
 from pandas import DataFrame
+from PIL import Image
 from pyarrow import Table
 from tqdm import tqdm
 
-from .data_inference import NomicDuplicatesOptions, NomicEmbedOptions, NomicProjectOptions, NomicTopicOptions
+from .data_inference import NomicDuplicatesOptions, NomicEmbedOptions, NomicTopicOptions, ProjectionOptions
 from .dataset import AtlasDataset, AtlasDataStream
 from .settings import *
 from .utils import arrow_iterator, b64int, get_random_name
@@ -21,13 +21,14 @@ from .utils import arrow_iterator, b64int, get_random_name
 
 def map_data(
     data: Optional[Union[DataFrame, List[Dict], Table]] = None,
+    blobs: Optional[List[Union[str, bytes, Image.Image]]] = None,
     embeddings: Optional[np.ndarray] = None,
     identifier: Optional[str] = None,
     description: str = "",
     id_field: Optional[str] = None,
     is_public: bool = True,
     indexed_field: Optional[str] = None,
-    projection: Union[bool, Dict, NomicProjectOptions] = True,
+    projection: Optional[Union[Dict, ProjectionOptions]] = None,
     topic_model: Union[bool, Dict, NomicTopicOptions] = True,
     duplicate_detection: Union[bool, Dict, NomicDuplicatesOptions] = True,
     embedding_model: Optional[Union[str, Dict, NomicEmbedOptions]] = None,
@@ -36,12 +37,14 @@ def map_data(
 
     Args:
         data: An ordered collection of the datapoints you are structuring. Can be a list of dictionaries, Pandas Dataframe or PyArrow Table.
+        blobs: A list of image paths, bytes, or PIL images to add to your image dataset that are stored locally.
         embeddings: An [N,d] numpy array containing the N embeddings to add.
         identifier: A name for your dataset that is used to generate the dataset identifier. A unique name will be chosen if not supplied.
         description: The description of your dataset
-        id_field: Specify your data unique id field. This field can be up 36 characters in length. If not specified, one will be created for you named `id_`.
+        id_field: Specify a field that uniquely identifies each datapoint. This field can be up 36 characters in length.
         is_public: Should the dataset be accessible outside your Nomic Atlas organization.
-        projection: Options to adjust Nomic Project - the dimensionality algorithm organizing your dataset.
+        indexed_field: The text field from the dataset that will be used to create embeddings, which determines the layout of the data map in Atlas. Required for text data but won't have an impact if uploading embeddings or image blobs.
+        projection: Options for configuring the 2D projection algorithm.
         topic_model: Options to adjust Nomic Topic - the topic model organizing your dataset.
         duplicate_detection: Options to adjust Nomic Duplicates - the duplicate detection algorithm.
         embedding_model: Options to adjust the embedding model used to embed your dataset.
@@ -54,10 +57,33 @@ def map_data(
             raise Exception("Your embeddings cannot be empty")
 
     if indexed_field is not None:
+        if embeddings is not None:
+            logger.warning("You have specified an indexed field but are using embeddings. Embeddings will be ignored.")
         modality = "text"
 
-    if id_field is None:
-        id_field = ATLAS_DEFAULT_ID_FIELD
+    if blobs is not None:
+        if embeddings is not None:
+            raise ValueError(
+                "You cannot pass both `blobs` and `embeddings` to map_data(). To create a map of images, include `blobs` and not `embeddings`. To create a map of embeddings with images as metadata, include your images as a field in your `data` parameter."
+            )
+        # change this when we support other modalities
+        modality = "image"
+        indexed_field = "_blob_hash"
+        if embedding_model is not None:
+            if isinstance(embedding_model, str):
+                model_name = embedding_model
+            elif isinstance(embedding_model, dict):
+                model_name = embedding_model["model"]
+            elif isinstance(embedding_model, NomicEmbedOptions):
+                model_name = embedding_model.model
+            else:
+                raise ValueError("embedding_model must be a string, dictionary, or NomicEmbedOptions object")
+
+            if model_name in ["nomic-embed-text-v1", "nomic-embed-text-v1.5"]:
+                raise Exception("You cannot use a text embedding model with blobs")
+        else:
+            # default to vision v1.5
+            embedding_model = NomicEmbedOptions(model="nomic-embed-vision-v1.5")
 
     project_name = get_random_name()
 
@@ -70,33 +96,6 @@ def map_data(
     if description:
         description = description
 
-    # no metadata was specified
-    added_id_field = False
-
-    if data is None and embeddings is not None:
-        data = [{ATLAS_DEFAULT_ID_FIELD: b64int(i)} for i in range(len(embeddings))]
-        added_id_field = True
-
-    if id_field == ATLAS_DEFAULT_ID_FIELD and data is not None:
-        if isinstance(data, list) and id_field not in data[0]:
-            added_id_field = True
-            for i in range(len(data)):
-                # do not modify object the user passed in - also ensures IDs are unique if two input datums are the same *object*
-                data[i] = data[i].copy()
-                data[i][id_field] = b64int(i)
-        elif isinstance(data, DataFrame) and id_field not in data.columns:
-            data[id_field] = [b64int(i) for i in range(data.shape[0])]
-            added_id_field = True
-        elif isinstance(data, pa.Table) and not id_field in data.column_names:  # type: ignore
-            ids = pa.array([b64int(i) for i in range(len(data))])
-            data = data.append_column(id_field, ids)  # type: ignore
-            added_id_field = True
-        elif id_field not in data[0]:
-            raise ValueError("map_data data must be a list of dicts, a pandas dataframe, or a pyarrow table")
-
-    if added_id_field:
-        logger.warning("An ID field was not specified in your data so one was generated for you in insertion order.")
-
     dataset = AtlasDataset(
         identifier=dataset_name, description=description, unique_id_field=id_field, is_public=is_public
     )
@@ -109,6 +108,8 @@ def map_data(
     # Add data by modality
     logger.info("Uploading data to Atlas.")
     try:
+        if isinstance(data, DataFrame):
+            data = data.to_dict(orient="records")
         if modality == "text":
             dataset.add_data(data=data)
         elif modality == "embedding":
@@ -116,6 +117,9 @@ def map_data(
                 embeddings=embeddings,
                 data=data,
             )
+        elif modality == "image":
+            dataset.add_data(blobs=blobs, data=data)
+
     except BaseException as e:
         if number_of_datums_before_upload == 0:
             logger.info(f"{dataset.identifier}: Deleting dataset due to failure in initial upload.")
@@ -128,7 +132,7 @@ def map_data(
         name=index_name,
         indexed_field=indexed_field,
         modality=modality,
-        projection=projection,
+        projection=projection,  # type: ignore[arg-type]
         topic_model=topic_model,
         duplicate_detection=duplicate_detection,
         embedding_model=embedding_model,
@@ -162,7 +166,7 @@ def map_embeddings(
     Args:
         embeddings: An [N,d] numpy array containing the batch of N embeddings to add.
         data: An [N,] element list of dictionaries containing metadata for each embedding.
-        id_field: Specify your data unique id field. This field can be up 36 characters in length. If not specified, one will be created for you named `id_`.
+        id_field: Specify a field that uniquely identifies each datapoint. This field can be up 36 characters in length.
         name: A name for your dataset. Specify in the format `organization/project` to create in a specific organization.
         description: A description for your map.
         is_public: Should this embedding map be public? Private maps can only be accessed by members of your organization.
@@ -210,7 +214,7 @@ def map_text(
     Args:
         data: An [N,] element iterable of dictionaries containing metadata for each embedding.
         indexed_field: The name the data field containing the text your want to map.
-        id_field: Specify your data unique id field. This field can be up 36 characters in length. If not specified, one will be created for you named `id_`.
+        id_field: Specify a field that uniquely identifies each datapoint. This field can be up 36 characters in length.
         name: A name for your dataset. Specify in the format `organization/project` to create in a specific organization.
         description: A description for your map.
         build_topic_model: Builds a hierarchical topic model over your data to discover patterns.

{nomic-3.0.32 → nomic-3.8.0}/nomic/aws/sagemaker.py

@@ -4,7 +4,7 @@ import json
 import logging
 import multiprocessing as mp
 from pathlib import PosixPath
-from typing import List, Optional, Union
+from typing import List, Optional, Tuple, Union
 
 import boto3
 import PIL
@@ -38,26 +38,6 @@ def parse_sagemaker_response(response):
     return resp["embeddings"]
 
 
-def preprocess_texts(texts: List[str], task_type: str = "search_document"):
-    """
-    Preprocess a list of texts for embedding using a sagemaker model.
-
-    Args:
-        texts: List of texts to be embedded.
-        task_type: The task type to use when embedding. One of `search_query`, `search_document`, `classification`, `clustering`
-
-    Returns:
-        List of texts formatted for sagemaker embedding.
-    """
-    assert task_type in [
-        "search_query",
-        "search_document",
-        "classification",
-        "clustering",
-    ], f"Invalid task type: {task_type}"
-    return [f"{task_type}: {text}" for text in texts]
-
-
 def batch_transform_text(
     s3_input_path: str,
     s3_output_path: str,
@@ -157,7 +137,13 @@ def embed_text(
         logger.warning("No texts to embed.")
         return None
 
-    texts = preprocess_texts(texts, task_type)
+    assert task_type in [
+        "search_query",
+        "search_document",
+        "classification",
+        "clustering",
+    ], f"Invalid task type: {task_type}"
+
     assert dimensionality in (
         64,
         128,
@@ -175,6 +161,7 @@ def embed_text(
                 "texts": texts[i : i + batch_size],
                 "binary": binary,
                 "dimensionality": dimensionality,
+                "task_type": task_type,
             }
         )
         response = client.invoke_endpoint(EndpointName=sagemaker_endpoint, Body=batch, ContentType="application/json")
@@ -187,7 +174,22 @@ def embed_text(
     }
 
 
-def preprocess_image(images: List[Union[str, "PIL.Image.Image", bytes]]) -> List[bytes]:
+# only way I could get sagemaker with multipart to work
+def prepare_multipart_request(images: List[Tuple[str, bytes]]) -> Tuple[bytes, bytes]:
+    # Prepare the multipart body
+    boundary = b"---------------------------Boundary"
+    body = b""
+    for i, (name, img_bytes) in enumerate(images):
+        body += b"--" + boundary + b"\r\n"
+        body += f'Content-Disposition: form-data; name="{name}"; filename="image_{i}.jpg"\r\n'.encode("utf-8")
+        body += b"Content-Type: image/jpeg\r\n\r\n"
+        body += img_bytes + b"\r\n"
+    body += b"--" + boundary + b"--\r\n"
+
+    return body, boundary
+
+
+def preprocess_image(images: List[Union[str, "PIL.Image.Image", bytes]]) -> Tuple[bytes, bytes]:
     """
     Preprocess a list of images for embedding using a sagemaker model.
 
@@ -210,17 +212,22 @@ def preprocess_image(images: List[Union[str, "PIL.Image.Image", bytes]]) -> List
         image = image.convert("RGB")
         buffered = io.BytesIO()
         image.save(buffered, format="JPEG")
-        encoded_image = buffered.getvalue()
-        encoded_images.append(encoded_image)
-    return encoded_images
+        encoded_images.append(("image_data", buffered.getvalue()))
 
+    body, boundary = prepare_multipart_request(encoded_images)
+    return body, boundary
 
-def sagemaker_image_request(image: Union[str, bytes, "PIL.Image.Image"], sagemaker_endpoint: str, region_name: str):
-    preprocessed_image = preprocess_image([image])
+
+def sagemaker_image_request(
+    images: List[Union[str, bytes, "PIL.Image.Image"]], sagemaker_endpoint: str, region_name: str
+):
+    body, boundary = preprocess_image(images)
 
     client = boto3.client("sagemaker-runtime", region_name=region_name)
     response = client.invoke_endpoint(
-        EndpointName=sagemaker_endpoint, Body=preprocessed_image[0], ContentType="image/jpeg"
+        EndpointName=sagemaker_endpoint,
+        Body=body,
+        ContentType=f'multipart/form-data; boundary={boundary.decode("utf-8")}',
     )
 
     return parse_sagemaker_response(response)
@@ -230,21 +237,18 @@ def embed_image(
     images: List[Union[str, "PIL.Image.Image", bytes]],
     sagemaker_endpoint: str,
     region_name: str,
-    model_name="nomic-embed-vision-v1",
+    model_name="nomic-embed-vision-v1.5",
+    batch_size=16,
 ) -> dict:
     embeddings = []
 
-    max_workers = mp.cpu_count()
     pbar = tqdm(total=len(images))
-    with concurrent.futures.ProcessPoolExecutor(max_workers=max_workers) as executor:
-        futures = []
-        for image in images:
-            future = executor.submit(sagemaker_image_request, image, sagemaker_endpoint, region_name)
-            future.add_done_callback(lambda p: pbar.update())
-            futures.append(future)
-
-        for future in concurrent.futures.as_completed(futures):
-            embeddings.extend(future.result())
+    for i in range(0, len(images), batch_size):
+        batch = images[i : i + batch_size]
+        embeddings.extend(
+            sagemaker_image_request(batch, sagemaker_endpoint=sagemaker_endpoint, region_name=region_name)
+        )
+        pbar.update(len(batch))
 
     return {
         "embeddings": embeddings,
@@ -260,7 +264,7 @@ def batch_transform_image(
     arn: Optional[str] = None,
     role: Optional[str] = None,
     max_payload: Optional[int] = 6,
-    instance_type: str = "ml.p3.2xlarge",
+    instance_type: str = "ml.g4dn.xlarge",
     n_instances: int = 1,
     wait: bool = True,
     logs: bool = True,

{nomic-3.0.32 → nomic-3.8.0}/nomic/cli.py

@@ -53,7 +53,7 @@ def login(token, tenant="production", domain=None):
         console.print("Authenticate with the Nomic API", style=style, justify="center")
         console.print(auth0_auth_endpoint, style=style, justify="center")
         console.print(
-            "Click the above link to retrieve your access token and then run `nomic login [token]`",
+            "Click the above link to retrieve your access token and then run `nomic login \\[token]`",
             style=style,
             justify="center",
         )