code
stringlengths 193
97.3k
| apis
sequencelengths 1
8
| extract_api
stringlengths 113
214k
|
|---|---|---|
import sys
import os
# this is needed to import classes from the API. it will be removed when the worker is refactored
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../')))
import time
import pika
import json
import pinecone
import logging
import weaviate
import redis
import lancedb
import pymongo
import pyarrow as pa
import numpy as np
import worker.config as config
import services.database.batch_service as batch_service
import services.database.job_service as job_service
from services.database.database import get_db, safe_db_operation
from shared.job_status import JobStatus
from shared.batch_status import BatchStatus
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
from pymilvus import Collection, connections
from shared.embeddings_type import EmbeddingsType
from shared.vector_db_type import VectorDBType
from shared.utils import generate_uuid_from_tuple
from urllib.parse import quote_plus
from services.rabbitmq.rabbit_service import create_connection_params
from pika.exceptions import AMQPConnectionError
logging.basicConfig(filename='./vdb-log.txt', level=logging.INFO)
logging.basicConfig(filename='./vdb-errors.txt', level=logging.ERROR)
def upload_batch(batch_id, chunks_with_embeddings):
batch = safe_db_operation(batch_service.get_batch, batch_id)
if batch.batch_status == BatchStatus.FAILED:
safe_db_operation(batch_service.update_batch_retry_count, batch.id, batch.retries+1)
logging.info(f"Retrying vector db upload of batch {batch.id}")
batch = safe_db_operation(batch_service.get_batch, batch_id)
vectors_uploaded = write_embeddings_to_vector_db(chunks_with_embeddings, batch.vector_db_metadata, batch.id, batch.job_id)
if vectors_uploaded:
status = safe_db_operation(batch_service.update_batch_status_with_successful_minibatch, batch.id)
update_batch_and_job_status(batch.job_id, status, batch.id)
else:
update_batch_and_job_status(batch.job_id, BatchStatus.FAILED, batch.id)
def write_embeddings_to_vector_db(chunks, vector_db_metadata, batch_id, job_id):
# NOTE: the legacy code expects a list of tuples, (text_chunk, embedding) of form (str, list[float])
text_embeddings_list = [(chunk['text'], chunk['vector']) for chunk in chunks]
job = safe_db_operation(job_service.get_job, job_id)
source_filename = job.source_filename
if vector_db_metadata.vector_db_type == VectorDBType.PINECONE:
upsert_list = create_pinecone_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename)
return write_embeddings_to_pinecone(upsert_list, vector_db_metadata)
elif vector_db_metadata.vector_db_type == VectorDBType.QDRANT:
upsert_list = create_qdrant_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename)
return write_embeddings_to_qdrant(upsert_list, vector_db_metadata)
elif vector_db_metadata.vector_db_type == VectorDBType.WEAVIATE:
return write_embeddings_to_weaviate(text_embeddings_list, vector_db_metadata, batch_id, job_id, source_filename)
elif vector_db_metadata.vector_db_type == VectorDBType.MILVUS:
upsert_list = create_milvus_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename)
return write_embeddings_to_milvus(upsert_list, vector_db_metadata)
elif vector_db_metadata.vector_db_type == VectorDBType.REDIS:
upsert_list = create_redis_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename)
return write_embeddings_to_redis(upsert_list, vector_db_metadata)
elif vector_db_metadata.vector_db_type == VectorDBType.LANCEDB:
upsert_list = create_lancedb_source_chunks(text_embeddings_list, batch_id, job_id, source_filename)
return write_embeddings_to_lancedb(upsert_list, batch_id)
elif vector_db_metadata.vector_db_type == VectorDBType.MONGODB:
upsert_list = create_mongodb_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename)
return write_embeddings_to_mongodb(upsert_list, vector_db_metadata)
else:
logging.error('Unsupported vector DB type: %s', vector_db_metadata.vector_db_type.value)
def create_mongodb_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename):
upsert_list = []
for i, (source_text, embedding) in enumerate(text_embeddings_list):
upsert_list.append(
{"_id": generate_uuid_from_tuple((job_id, batch_id, i)),
"values": embedding,
"source_text": source_text,
"source_document": source_filename
})
return upsert_list
def write_embeddings_to_mongodb(upsert_list, vector_db_metadata):
mongo_conn_uri = vector_db_metadata.environment
mongo_password = quote_plus(os.getenv('VECTOR_DB_KEY'))
mongo_conn_uri = mongo_conn_uri.replace("<password>", mongo_password)
mongo_client = pymongo.MongoClient(mongo_conn_uri)
db_name, collection = vector_db_metadata.index_name.split(".")
db = mongo_client[db_name]
try:
db.command("ping")
except Exception as e:
logging.error(f"Error connecting to MongoDB via python client: {e}")
return None
if collection not in db.list_collection_names():
logging.error(f"Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}")
return None
index = db.get_collection(collection)
logging.info(f"Starting MongoDB upsert for {len(upsert_list)} vectors")
batch_size = config.PINECONE_BATCH_SIZE
vectors_uploaded = 0
for i in range(0,len(upsert_list), batch_size):
try:
upsert_batch = upsert_list[i:i+batch_size]
upsert_response = index.insert_many(upsert_batch)
vectors_uploaded += len(upsert_batch)
except Exception as e:
logging.error('Error writing embeddings to Mongo:', e)
return None
logging.info(f"Successfully uploaded {vectors_uploaded} vectors to MongoDB")
return vectors_uploaded
def create_pinecone_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename):
upsert_list = []
for i, (source_text, embedding) in enumerate(text_embeddings_list):
upsert_list.append(
{"id": generate_uuid_from_tuple((job_id, batch_id, i)),
"values": embedding,
"metadata": {"source_text": source_text, "source_document": source_filename}})
return upsert_list
def write_embeddings_to_pinecone(upsert_list, vector_db_metadata):
pinecone_api_key = os.getenv('VECTOR_DB_KEY')
pinecone.init(api_key=pinecone_api_key, environment=vector_db_metadata.environment)
index = pinecone.GRPCIndex(vector_db_metadata.index_name)
if not index:
logging.error(f"Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}")
return None
logging.info(f"Starting pinecone upsert for {len(upsert_list)} vectors")
batch_size = config.PINECONE_BATCH_SIZE
vectors_uploaded = 0
for i in range(0,len(upsert_list), batch_size):
try:
upsert_response = index.upsert(vectors=upsert_list[i:i+batch_size])
vectors_uploaded += upsert_response.upserted_count
except Exception as e:
logging.error('Error writing embeddings to pinecone:', e)
return None
logging.info(f"Successfully uploaded {vectors_uploaded} vectors to pinecone")
return vectors_uploaded
def create_redis_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename):
ids = []
source_texts = []
source_documents = []
embeddings = []
for i, (source_text, embedding) in enumerate(text_embeddings_list):
ids.append(generate_uuid_from_tuple((job_id, batch_id, i)))
source_texts.append(source_text)
embeddings.append(embedding)
source_documents.append(source_filename)
return [ids, source_texts, embeddings, source_documents]
def write_embeddings_to_redis(upsert_list, vector_db_metadata):
redis_client = redis.from_url(url=vector_db_metadata.environment, password=os.getenv('VECTOR_DB_KEY'), decode_responses=True)
try:
redis_client.ft(vector_db_metadata.index_name).info()
except redis.exceptions.ResponseError as e:
if "Unknown Index name" in str(e):
logging.error(f"Index {vector_db_metadata.index_name} does not exist at redis URL {vector_db_metadata.environment}")
return None
logging.info(f"Starting redis upsert for {len(upsert_list)} vectors")
redis_pipeline = redis_client.pipeline()
for i in range(0,len(upsert_list[0])):
key = f'{vector_db_metadata.collection}:{upsert_list[0][i]}'
obj = {"source_data": upsert_list[1][i], "embeddings": np.array(upsert_list[2][i]).tobytes(), "source_document": upsert_list[3][i]}
redis_pipeline.hset(key, mapping=obj)
res = redis_pipeline.execute()
logging.info(f"Successfully uploaded {len(res)} vectors to redis")
return len(res)
def create_qdrant_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename):
upsert_list = []
for i, (source_text, embedding) in enumerate(text_embeddings_list):
upsert_list.append(
PointStruct(
id=generate_uuid_from_tuple((job_id, batch_id, i)),
vector=embedding,
payload={"source_text": source_text, "source_document": source_filename}
)
)
return upsert_list
def write_embeddings_to_qdrant(upsert_list, vector_db_metadata):
qdrant_client = QdrantClient(
url=vector_db_metadata.environment,
api_key=os.getenv('VECTOR_DB_KEY'),
grpc_port=6334,
prefer_grpc=True,
timeout=5
) if vector_db_metadata.environment != os.getenv('LOCAL_VECTOR_DB') else QdrantClient(os.getenv('LOCAL_VECTOR_DB'), port=6333)
index = qdrant_client.get_collection(collection_name=vector_db_metadata.index_name)
if not index:
logging.error(f"Collection {vector_db_metadata.index_name} does not exist at cluster URL {vector_db_metadata.environment}")
return None
logging.info(f"Starting qdrant upsert for {len(upsert_list)} vectors")
batch_size = config.PINECONE_BATCH_SIZE
for i in range(0, len(upsert_list), batch_size):
try:
qdrant_client.upsert(
collection_name=vector_db_metadata.index_name,
points=upsert_list[i:i+batch_size]
)
except Exception as e:
logging.error('Error writing embeddings to qdrant:', e)
return None
logging.info(f"Successfully uploaded {len(upsert_list)} vectors to qdrant")
return len(upsert_list)
def write_embeddings_to_weaviate(text_embeddings_list, vector_db_metadata, batch_id, job_id, source_filename):
client = weaviate.Client(
url=vector_db_metadata.environment,
auth_client_secret=weaviate.AuthApiKey(api_key=os.getenv('VECTOR_DB_KEY')),
) if vector_db_metadata.environment != os.getenv('LOCAL_VECTOR_DB') else weaviate.Client(url=vector_db_metadata.environment)
index = client.schema.get()
class_list = [class_dict["class"] for class_dict in index["classes"]]
if not index or not vector_db_metadata.index_name in class_list:
logging.error(f"Collection {vector_db_metadata.index_name} does not exist at cluster URL {vector_db_metadata.environment}")
return None
logging.info(f"Starting Weaviate upsert for {len(text_embeddings_list)} vectors")
try:
with client.batch(batch_size=config.PINECONE_BATCH_SIZE, dynamic=True, num_workers=2) as batch:
for i, (text, vector) in enumerate(text_embeddings_list):
properties = {
"source_data": text,
"vectoflow_id": generate_uuid_from_tuple((job_id, batch_id, i)),
"source_document": source_filename
}
client.batch.add_data_object(
properties,
vector_db_metadata.index_name,
vector=vector
)
except Exception as e:
logging.error('Error writing embeddings to weaviate: %s', e)
return None
logging.info(f"Successfully uploaded {len(text_embeddings_list)} vectors to Weaviate")
return len(text_embeddings_list)
def create_milvus_source_chunk_dict(text_embeddings_list, batch_id, job_id, source_filename):
ids = []
source_texts = []
embeddings = []
source_filenames = []
for i, (source_text, embedding) in enumerate(text_embeddings_list):
ids.append(generate_uuid_from_tuple((job_id, batch_id, i)))
source_texts.append(source_text)
embeddings.append(embedding)
source_filenames.append(source_filename)
return [ids, source_texts, embeddings, source_filenames]
def write_embeddings_to_milvus(upsert_list, vector_db_metadata):
if vector_db_metadata.environment != os.getenv('LOCAL_VECTOR_DB'):
connections.connect("default",
uri = vector_db_metadata.environment,
token = os.getenv('VECTOR_DB_KEY')
)
else:
connections.connect("default",
host = vector_db_metadata.environment
)
collection = Collection(vector_db_metadata.index_name)
if not collection:
logging.error(f"Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}")
return None
logging.info(f"Starting Milvus insert for {len(upsert_list)} vectors")
batch_size = config.PINECONE_BATCH_SIZE
vectors_uploaded = 0
for i in range(0,len(upsert_list), batch_size):
try:
insert_response = collection.insert(upsert_list[i:i+batch_size])
vectors_uploaded += insert_response.insert_count
except Exception as e:
logging.error('Error writing embeddings to milvus: %s', e)
return None
logging.info(f"Successfully uploaded {vectors_uploaded} vectors to milvus")
return vectors_uploaded
def create_lancedb_source_chunks(text_embeddings_list, batch_id, job_id, source_filename):
upsert_list = []
for i, (source_text, embedding) in enumerate(text_embeddings_list):
upsert_list.append(
{
"id": generate_uuid_from_tuple((job_id, batch_id, i)),
"vector": embedding,
"source_text": source_text,
"source_document": source_filename
}
)
return upsert_list
def write_embeddings_to_lancedb(upsert_list, batch_id):
# right now only local connection, since its serverless and their cloud is in beta
batch = safe_db_operation(batch_service.get_batch, batch_id)
db = lancedb.connect(batch.vector_db_metadata.environment)
try:
table = db.open_table(batch.vector_db_metadata.index_name)
except FileNotFoundError as e:
logging.info(f"Table {batch.vector_db_metadata.index_name} does not exist in environment {batch.vector_db_metadata.environment}.")
if batch.embeddings_metadata.embeddings_type == EmbeddingsType.OPEN_AI:
schema = pa.schema(
[
pa.field("id", pa.string()),
pa.field("vector", pa.list_(pa.float32(), 1536)),
pa.field("source_text", pa.string()),
pa.field("source_document", pa.string()),
])
table = db.create_table(batch.vector_db_metadata.index_name, schema=schema)
logging.info(f"Created table {batch.vector_db_metadata.index_name} in environment {batch.vector_db_metadata.environment}.")
else:
logging.error(f"Embeddings type {batch.embeddings_metadata.embeddings_type} not supported for LanceDB. Only Open AI")
return None
logging.info(f"Starting LanceDB upsert for {len(upsert_list)} vectors")
batch_size = config.PINECONE_BATCH_SIZE
vectors_uploaded = 0
for i in range(0,len(upsert_list), batch_size):
try:
table.add(data=upsert_list[i:i+batch_size])
vectors_uploaded += batch_size
except Exception as e:
logging.error('Error writing embeddings to lance db:', e)
return None
logging.info(f"Successfully uploaded {vectors_uploaded} vectors to lance db")
return vectors_uploaded
# TODO: refactor into utils
def update_batch_and_job_status(job_id, batch_status, batch_id):
try:
if not job_id and batch_id:
job = safe_db_operation(batch_service.get_batch, batch_id)
job_id = job.job_id
updated_batch_status = safe_db_operation(batch_service.update_batch_status, batch_id, batch_status)
job = safe_db_operation(job_service.update_job_with_batch, job_id, updated_batch_status)
if job.job_status == JobStatus.COMPLETED:
logging.info(f"Job {job_id} completed successfully")
elif job.job_status == JobStatus.PARTIALLY_COMPLETED:
logging.info(f"Job {job_id} partially completed. {job.batches_succeeded} out of {job.total_batches} batches succeeded")
except Exception as e:
logging.error('Error updating job and batch status: %s', e)
safe_db_operation(job_service.update_job_status, job_id, JobStatus.FAILED)
def callback(ch, method, properties, body):
# do these outside the try-catch so it can update the batch status if there's an error
# if this parsing logic fails, the batch shouldn't be marked as failed
data = json.loads(body)
batch_id, chunks_with_embeddings, vector_db_key = data
if vector_db_key:
os.environ["VECTOR_DB_KEY"] = vector_db_key
else:
logging.info("No vector DB key provided")
try:
logging.info("Batch retrieved successfully")
upload_batch(batch_id, chunks_with_embeddings)
logging.info("Batch processed successfully")
except Exception as e:
logging.error('Error processing batch: %s', e)
update_batch_and_job_status(None, batch_id, BatchStatus.FAILED)
ch.basic_ack(delivery_tag=method.delivery_tag)
def start_connection(max_retries=5, retry_delay=5):
for attempt in range(max_retries):
try:
connection_params = create_connection_params()
connection = pika.BlockingConnection(connection_params)
channel = connection.channel()
queue_name = os.getenv('VDB_UPLOAD_QUEUE')
channel.queue_declare(queue=queue_name)
channel.basic_consume(queue=queue_name, on_message_callback=callback)
logging.info('Waiting for messages.')
channel.start_consuming()
return # If successful, exit the function
except AMQPConnectionError as e:
logging.error('AMQP Connection Error: %s', e)
except Exception as e:
logging.error('Unexpected error: %s', e)
finally:
if connection and not connection.is_closed:
connection.close()
logging.info('Retrying to connect in %s seconds (Attempt %s/%s)', retry_delay, attempt + 1, max_retries)
time.sleep(retry_delay)
if __name__ == "__main__":
while True:
try:
start_connection()
except Exception as e:
logging.error('Error in start_connection: %s', e)
logging.info('Restarting start_connection after encountering an error.')
time.sleep(config.PIKA_RETRY_INTERVAL)
| [
"lancedb.connect"
] | [((1090, 1155), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': '"""./vdb-log.txt"""', 'level': 'logging.INFO'}), "(filename='./vdb-log.txt', level=logging.INFO)\n", (1109, 1155), False, 'import logging\n'), ((1156, 1225), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': '"""./vdb-errors.txt"""', 'level': 'logging.ERROR'}), "(filename='./vdb-errors.txt', level=logging.ERROR)\n", (1175, 1225), False, 'import logging\n'), ((1291, 1343), 'services.database.database.safe_db_operation', 'safe_db_operation', (['batch_service.get_batch', 'batch_id'], {}), '(batch_service.get_batch, batch_id)\n', (1308, 1343), False, 'from services.database.database import get_db, safe_db_operation\n'), ((1570, 1622), 'services.database.database.safe_db_operation', 'safe_db_operation', (['batch_service.get_batch', 'batch_id'], {}), '(batch_service.get_batch, batch_id)\n', (1587, 1622), False, 'from services.database.database import get_db, safe_db_operation\n'), ((2324, 2370), 'services.database.database.safe_db_operation', 'safe_db_operation', (['job_service.get_job', 'job_id'], {}), '(job_service.get_job, job_id)\n', (2341, 2370), False, 'from services.database.database import get_db, safe_db_operation\n'), ((4945, 4980), 'pymongo.MongoClient', 'pymongo.MongoClient', (['mongo_conn_uri'], {}), '(mongo_conn_uri)\n', (4964, 4980), False, 'import pymongo\n'), ((6003, 6079), 'logging.info', 'logging.info', (['f"""Successfully uploaded {vectors_uploaded} vectors to MongoDB"""'], {}), "(f'Successfully uploaded {vectors_uploaded} vectors to MongoDB')\n", (6015, 6079), False, 'import logging\n'), ((6634, 6660), 'os.getenv', 'os.getenv', (['"""VECTOR_DB_KEY"""'], {}), "('VECTOR_DB_KEY')\n", (6643, 6660), False, 'import os\n'), ((6665, 6753), 'pinecone.init', 'pinecone.init', ([], {'api_key': 'pinecone_api_key', 'environment': 'vector_db_metadata.environment'}), '(api_key=pinecone_api_key, environment=vector_db_metadata.\n environment)\n', (6678, 6753), False, 'import pinecone\n'), ((6761, 6810), 'pinecone.GRPCIndex', 'pinecone.GRPCIndex', (['vector_db_metadata.index_name'], {}), '(vector_db_metadata.index_name)\n', (6779, 6810), False, 'import pinecone\n'), ((7471, 7548), 'logging.info', 'logging.info', (['f"""Successfully uploaded {vectors_uploaded} vectors to pinecone"""'], {}), "(f'Successfully uploaded {vectors_uploaded} vectors to pinecone')\n", (7483, 7548), False, 'import logging\n'), ((13446, 13487), 'pymilvus.Collection', 'Collection', (['vector_db_metadata.index_name'], {}), '(vector_db_metadata.index_name)\n', (13456, 13487), False, 'from pymilvus import Collection, connections\n'), ((14146, 14221), 'logging.info', 'logging.info', (['f"""Successfully uploaded {vectors_uploaded} vectors to milvus"""'], {}), "(f'Successfully uploaded {vectors_uploaded} vectors to milvus')\n", (14158, 14221), False, 'import logging\n'), ((14884, 14936), 'services.database.database.safe_db_operation', 'safe_db_operation', (['batch_service.get_batch', 'batch_id'], {}), '(batch_service.get_batch, batch_id)\n', (14901, 14936), False, 'from services.database.database import get_db, safe_db_operation\n'), ((14946, 14999), 'lancedb.connect', 'lancedb.connect', (['batch.vector_db_metadata.environment'], {}), '(batch.vector_db_metadata.environment)\n', (14961, 14999), False, 'import lancedb\n'), ((16477, 16554), 'logging.info', 'logging.info', (['f"""Successfully uploaded {vectors_uploaded} vectors to lance db"""'], {}), "(f'Successfully uploaded {vectors_uploaded} vectors to lance db')\n", (16489, 16554), False, 'import logging\n'), ((17756, 17772), 'json.loads', 'json.loads', (['body'], {}), '(body)\n', (17766, 17772), False, 'import json\n'), ((1401, 1492), 'services.database.database.safe_db_operation', 'safe_db_operation', (['batch_service.update_batch_retry_count', 'batch.id', '(batch.retries + 1)'], {}), '(batch_service.update_batch_retry_count, batch.id, batch.\n retries + 1)\n', (1418, 1492), False, 'from services.database.database import get_db, safe_db_operation\n'), ((1494, 1556), 'logging.info', 'logging.info', (['f"""Retrying vector db upload of batch {batch.id}"""'], {}), "(f'Retrying vector db upload of batch {batch.id}')\n", (1506, 1556), False, 'import logging\n'), ((1793, 1886), 'services.database.database.safe_db_operation', 'safe_db_operation', (['batch_service.update_batch_status_with_successful_minibatch', 'batch.id'], {}), '(batch_service.\n update_batch_status_with_successful_minibatch, batch.id)\n', (1810, 1886), False, 'from services.database.database import get_db, safe_db_operation\n'), ((4823, 4849), 'os.getenv', 'os.getenv', (['"""VECTOR_DB_KEY"""'], {}), "('VECTOR_DB_KEY')\n", (4832, 4849), False, 'import os\n'), ((5302, 5430), 'logging.error', 'logging.error', (['f"""Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}"""'], {}), "(\n f'Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}'\n )\n", (5315, 5430), False, 'import logging\n'), ((6837, 6965), 'logging.error', 'logging.error', (['f"""Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}"""'], {}), "(\n f'Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}'\n )\n", (6850, 6965), False, 'import logging\n'), ((10133, 10266), 'logging.error', 'logging.error', (['f"""Collection {vector_db_metadata.index_name} does not exist at cluster URL {vector_db_metadata.environment}"""'], {}), "(\n f'Collection {vector_db_metadata.index_name} does not exist at cluster URL {vector_db_metadata.environment}'\n )\n", (10146, 10266), False, 'import logging\n'), ((11215, 11266), 'weaviate.Client', 'weaviate.Client', ([], {'url': 'vector_db_metadata.environment'}), '(url=vector_db_metadata.environment)\n', (11230, 11266), False, 'import weaviate\n'), ((11451, 11584), 'logging.error', 'logging.error', (['f"""Collection {vector_db_metadata.index_name} does not exist at cluster URL {vector_db_metadata.environment}"""'], {}), "(\n f'Collection {vector_db_metadata.index_name} does not exist at cluster URL {vector_db_metadata.environment}'\n )\n", (11464, 11584), False, 'import logging\n'), ((13141, 13169), 'os.getenv', 'os.getenv', (['"""LOCAL_VECTOR_DB"""'], {}), "('LOCAL_VECTOR_DB')\n", (13150, 13169), False, 'import os\n'), ((13336, 13403), 'pymilvus.connections.connect', 'connections.connect', (['"""default"""'], {'host': 'vector_db_metadata.environment'}), "('default', host=vector_db_metadata.environment)\n", (13355, 13403), False, 'from pymilvus import Collection, connections\n'), ((13519, 13647), 'logging.error', 'logging.error', (['f"""Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}"""'], {}), "(\n f'Index {vector_db_metadata.index_name} does not exist in environment {vector_db_metadata.environment}'\n )\n", (13532, 13647), False, 'import logging\n'), ((16856, 16932), 'services.database.database.safe_db_operation', 'safe_db_operation', (['batch_service.update_batch_status', 'batch_id', 'batch_status'], {}), '(batch_service.update_batch_status, batch_id, batch_status)\n', (16873, 16932), False, 'from services.database.database import get_db, safe_db_operation\n'), ((16947, 17033), 'services.database.database.safe_db_operation', 'safe_db_operation', (['job_service.update_job_with_batch', 'job_id', 'updated_batch_status'], {}), '(job_service.update_job_with_batch, job_id,\n updated_batch_status)\n', (16964, 17033), False, 'from services.database.database import get_db, safe_db_operation\n'), ((17925, 17966), 'logging.info', 'logging.info', (['"""No vector DB key provided"""'], {}), "('No vector DB key provided')\n", (17937, 17966), False, 'import logging\n'), ((17989, 18033), 'logging.info', 'logging.info', (['"""Batch retrieved successfully"""'], {}), "('Batch retrieved successfully')\n", (18001, 18033), False, 'import logging\n'), ((18097, 18141), 'logging.info', 'logging.info', (['"""Batch processed successfully"""'], {}), "('Batch processed successfully')\n", (18109, 18141), False, 'import logging\n'), ((19271, 19379), 'logging.info', 'logging.info', (['"""Retrying to connect in %s seconds (Attempt %s/%s)"""', 'retry_delay', '(attempt + 1)', 'max_retries'], {}), "('Retrying to connect in %s seconds (Attempt %s/%s)',\n retry_delay, attempt + 1, max_retries)\n", (19283, 19379), False, 'import logging\n'), ((19384, 19407), 'time.sleep', 'time.sleep', (['retry_delay'], {}), '(retry_delay)\n', (19394, 19407), False, 'import time\n'), ((168, 193), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (183, 193), False, 'import os\n'), ((5151, 5219), 'logging.error', 'logging.error', (['f"""Error connecting to MongoDB via python client: {e}"""'], {}), "(f'Error connecting to MongoDB via python client: {e}')\n", (5164, 5219), False, 'import logging\n'), ((7844, 7891), 'shared.utils.generate_uuid_from_tuple', 'generate_uuid_from_tuple', (['(job_id, batch_id, i)'], {}), '((job_id, batch_id, i))\n', (7868, 7891), False, 'from shared.utils import generate_uuid_from_tuple\n'), ((8226, 8252), 'os.getenv', 'os.getenv', (['"""VECTOR_DB_KEY"""'], {}), "('VECTOR_DB_KEY')\n", (8235, 8252), False, 'import os\n'), ((9930, 9958), 'os.getenv', 'os.getenv', (['"""LOCAL_VECTOR_DB"""'], {}), "('LOCAL_VECTOR_DB')\n", (9939, 9958), False, 'import os\n'), ((9977, 10005), 'os.getenv', 'os.getenv', (['"""LOCAL_VECTOR_DB"""'], {}), "('LOCAL_VECTOR_DB')\n", (9986, 10005), False, 'import os\n'), ((11181, 11209), 'os.getenv', 'os.getenv', (['"""LOCAL_VECTOR_DB"""'], {}), "('LOCAL_VECTOR_DB')\n", (11190, 11209), False, 'import os\n'), ((12316, 12376), 'logging.error', 'logging.error', (['"""Error writing embeddings to weaviate: %s"""', 'e'], {}), "('Error writing embeddings to weaviate: %s', e)\n", (12329, 12376), False, 'import logging\n'), ((12797, 12844), 'shared.utils.generate_uuid_from_tuple', 'generate_uuid_from_tuple', (['(job_id, batch_id, i)'], {}), '((job_id, batch_id, i))\n', (12821, 12844), False, 'from shared.utils import generate_uuid_from_tuple\n'), ((15119, 15259), 'logging.info', 'logging.info', (['f"""Table {batch.vector_db_metadata.index_name} does not exist in environment {batch.vector_db_metadata.environment}."""'], {}), "(\n f'Table {batch.vector_db_metadata.index_name} does not exist in environment {batch.vector_db_metadata.environment}.'\n )\n", (15131, 15259), False, 'import logging\n'), ((16740, 16792), 'services.database.database.safe_db_operation', 'safe_db_operation', (['batch_service.get_batch', 'batch_id'], {}), '(batch_service.get_batch, batch_id)\n', (16757, 16792), False, 'from services.database.database import get_db, safe_db_operation\n'), ((17092, 17144), 'logging.info', 'logging.info', (['f"""Job {job_id} completed successfully"""'], {}), "(f'Job {job_id} completed successfully')\n", (17104, 17144), False, 'import logging\n'), ((17391, 17450), 'logging.error', 'logging.error', (['"""Error updating job and batch status: %s"""', 'e'], {}), "('Error updating job and batch status: %s', e)\n", (17404, 17450), False, 'import logging\n'), ((17459, 17533), 'services.database.database.safe_db_operation', 'safe_db_operation', (['job_service.update_job_status', 'job_id', 'JobStatus.FAILED'], {}), '(job_service.update_job_status, job_id, JobStatus.FAILED)\n', (17476, 17533), False, 'from services.database.database import get_db, safe_db_operation\n'), ((18177, 18223), 'logging.error', 'logging.error', (['"""Error processing batch: %s"""', 'e'], {}), "('Error processing batch: %s', e)\n", (18190, 18223), False, 'import logging\n'), ((18485, 18511), 'services.rabbitmq.rabbit_service.create_connection_params', 'create_connection_params', ([], {}), '()\n', (18509, 18511), False, 'from services.rabbitmq.rabbit_service import create_connection_params\n'), ((18537, 18579), 'pika.BlockingConnection', 'pika.BlockingConnection', (['connection_params'], {}), '(connection_params)\n', (18560, 18579), False, 'import pika\n'), ((18649, 18678), 'os.getenv', 'os.getenv', (['"""VDB_UPLOAD_QUEUE"""'], {}), "('VDB_UPLOAD_QUEUE')\n", (18658, 18678), False, 'import os\n'), ((18827, 18864), 'logging.info', 'logging.info', (['"""Waiting for messages."""'], {}), "('Waiting for messages.')\n", (18839, 18864), False, 'import logging\n'), ((4463, 4510), 'shared.utils.generate_uuid_from_tuple', 'generate_uuid_from_tuple', (['(job_id, batch_id, i)'], {}), '((job_id, batch_id, i))\n', (4487, 4510), False, 'from shared.utils import generate_uuid_from_tuple\n'), ((5915, 5969), 'logging.error', 'logging.error', (['"""Error writing embeddings to Mongo:"""', 'e'], {}), "('Error writing embeddings to Mongo:', e)\n", (5928, 5969), False, 'import logging\n'), ((6345, 6392), 'shared.utils.generate_uuid_from_tuple', 'generate_uuid_from_tuple', (['(job_id, batch_id, i)'], {}), '((job_id, batch_id, i))\n', (6369, 6392), False, 'from shared.utils import generate_uuid_from_tuple\n'), ((7380, 7437), 'logging.error', 'logging.error', (['"""Error writing embeddings to pinecone:"""', 'e'], {}), "('Error writing embeddings to pinecone:', e)\n", (7393, 7437), False, 'import logging\n'), ((8456, 8582), 'logging.error', 'logging.error', (['f"""Index {vector_db_metadata.index_name} does not exist at redis URL {vector_db_metadata.environment}"""'], {}), "(\n f'Index {vector_db_metadata.index_name} does not exist at redis URL {vector_db_metadata.environment}'\n )\n", (8469, 8582), False, 'import logging\n'), ((9790, 9816), 'os.getenv', 'os.getenv', (['"""VECTOR_DB_KEY"""'], {}), "('VECTOR_DB_KEY')\n", (9799, 9816), False, 'import os\n'), ((10674, 10729), 'logging.error', 'logging.error', (['"""Error writing embeddings to qdrant:"""', 'e'], {}), "('Error writing embeddings to qdrant:', e)\n", (10687, 10729), False, 'import logging\n'), ((13281, 13307), 'os.getenv', 'os.getenv', (['"""VECTOR_DB_KEY"""'], {}), "('VECTOR_DB_KEY')\n", (13290, 13307), False, 'import os\n'), ((14054, 14112), 'logging.error', 'logging.error', (['"""Error writing embeddings to milvus: %s"""', 'e'], {}), "('Error writing embeddings to milvus: %s', e)\n", (14067, 14112), False, 'import logging\n'), ((14499, 14546), 'shared.utils.generate_uuid_from_tuple', 'generate_uuid_from_tuple', (['(job_id, batch_id, i)'], {}), '((job_id, batch_id, i))\n', (14523, 14546), False, 'from shared.utils import generate_uuid_from_tuple\n'), ((15739, 15872), 'logging.info', 'logging.info', (['f"""Created table {batch.vector_db_metadata.index_name} in environment {batch.vector_db_metadata.environment}."""'], {}), "(\n f'Created table {batch.vector_db_metadata.index_name} in environment {batch.vector_db_metadata.environment}.'\n )\n", (15751, 15872), False, 'import logging\n'), ((15889, 16016), 'logging.error', 'logging.error', (['f"""Embeddings type {batch.embeddings_metadata.embeddings_type} not supported for LanceDB. Only Open AI"""'], {}), "(\n f'Embeddings type {batch.embeddings_metadata.embeddings_type} not supported for LanceDB. Only Open AI'\n )\n", (15902, 16016), False, 'import logging\n'), ((16386, 16443), 'logging.error', 'logging.error', (['"""Error writing embeddings to lance db:"""', 'e'], {}), "('Error writing embeddings to lance db:', e)\n", (16399, 16443), False, 'import logging\n'), ((17219, 17348), 'logging.info', 'logging.info', (['f"""Job {job_id} partially completed. {job.batches_succeeded} out of {job.total_batches} batches succeeded"""'], {}), "(\n f'Job {job_id} partially completed. {job.batches_succeeded} out of {job.total_batches} batches succeeded'\n )\n", (17231, 17348), False, 'import logging\n'), ((19024, 19069), 'logging.error', 'logging.error', (['"""AMQP Connection Error: %s"""', 'e'], {}), "('AMQP Connection Error: %s', e)\n", (19037, 19069), False, 'import logging\n'), ((19113, 19153), 'logging.error', 'logging.error', (['"""Unexpected error: %s"""', 'e'], {}), "('Unexpected error: %s', e)\n", (19126, 19153), False, 'import logging\n'), ((19539, 19588), 'logging.error', 'logging.error', (['"""Error in start_connection: %s"""', 'e'], {}), "('Error in start_connection: %s', e)\n", (19552, 19588), False, 'import logging\n'), ((19601, 19673), 'logging.info', 'logging.info', (['"""Restarting start_connection after encountering an error."""'], {}), "('Restarting start_connection after encountering an error.')\n", (19613, 19673), False, 'import logging\n'), ((19686, 19724), 'time.sleep', 'time.sleep', (['config.PIKA_RETRY_INTERVAL'], {}), '(config.PIKA_RETRY_INTERVAL)\n', (19696, 19724), False, 'import time\n'), ((8898, 8925), 'numpy.array', 'np.array', (['upsert_list[2][i]'], {}), '(upsert_list[2][i])\n', (8906, 8925), True, 'import numpy as np\n'), ((9410, 9457), 'shared.utils.generate_uuid_from_tuple', 'generate_uuid_from_tuple', (['(job_id, batch_id, i)'], {}), '((job_id, batch_id, i))\n', (9434, 9457), False, 'from shared.utils import generate_uuid_from_tuple\n'), ((11977, 12024), 'shared.utils.generate_uuid_from_tuple', 'generate_uuid_from_tuple', (['(job_id, batch_id, i)'], {}), '((job_id, batch_id, i))\n', (12001, 12024), False, 'from shared.utils import generate_uuid_from_tuple\n'), ((11109, 11135), 'os.getenv', 'os.getenv', (['"""VECTOR_DB_KEY"""'], {}), "('VECTOR_DB_KEY')\n", (11118, 11135), False, 'import os\n'), ((15416, 15427), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (15425, 15427), True, 'import pyarrow as pa\n'), ((15544, 15555), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (15553, 15555), True, 'import pyarrow as pa\n'), ((15606, 15617), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (15615, 15617), True, 'import pyarrow as pa\n'), ((4137, 4230), 'logging.error', 'logging.error', (['"""Unsupported vector DB type: %s"""', 'vector_db_metadata.vector_db_type.value'], {}), "('Unsupported vector DB type: %s', vector_db_metadata.\n vector_db_type.value)\n", (4150, 4230), False, 'import logging\n'), ((15478, 15490), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (15488, 15490), True, 'import pyarrow as pa\n')] |
import streamlit as st
import sqlite3
import streamlit_antd_components as sac
import pandas as pd
import os
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.document_loaders import UnstructuredFileLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import LanceDB
import lancedb
import pickle
import configparser
import ast
class ConfigHandler:
def __init__(self):
self.config = configparser.ConfigParser()
self.config.read('config.ini')
def get_config_values(self, section, key):
value = self.config.get(section, key)
try:
# Try converting the string value to a Python data structure
return ast.literal_eval(value)
except (SyntaxError, ValueError):
# If not a data structure, return the plain string
return value
config_handler = ConfigHandler()
PM = config_handler.get_config_values('constants', 'PM')
USERS = config_handler.get_config_values('constants', 'USERS')
SA = config_handler.get_config_values('constants', 'SA')
AD = config_handler.get_config_values('constants', 'AD')
# Create or check for the 'database' directory in the current working directory
cwd = os.getcwd()
WORKING_DIRECTORY = os.path.join(cwd, "database")
if not os.path.exists(WORKING_DIRECTORY):
os.makedirs(WORKING_DIRECTORY)
if st.secrets["sql_ext_path"] == "None":
WORKING_DATABASE= os.path.join(WORKING_DIRECTORY , st.secrets["default_db"])
else:
WORKING_DATABASE= st.secrets["sql_ext_path"]
def fetch_vectorstores_with_usernames():
conn = sqlite3.connect(WORKING_DATABASE)
cursor = conn.cursor()
query = '''
SELECT
Vector_Stores.vs_id,
Subject.subject_name,
Topic.topic_name,
Vector_Stores.vectorstore_name,
Users.username,
Vector_Stores.sharing_enabled
FROM Vector_Stores
JOIN Users ON Vector_Stores.user_id = Users.user_id
LEFT JOIN Subject ON Vector_Stores.subject = Subject.id
LEFT JOIN Topic ON Vector_Stores.topic = Topic.id;
'''
cursor.execute(query)
data = cursor.fetchall()
conn.close()
return data
def display_vectorstores():
data = fetch_vectorstores_with_usernames()
df = pd.DataFrame(data, columns=["KB ID", "Function Name", "Process Name", "KB Name", "Username", "sharing_enabled"])
# Convert the 'sharing_enabled' values
df["sharing_enabled"] = df["sharing_enabled"].apply(lambda x: '✔' if x == 1 else '')
st.dataframe(
df,
use_container_width=True,
column_order=["KB ID", "Function Name", "Process Name", "KB Name", "Username", "sharing_enabled"]
)
def fetch_all_files():
"""
Fetch all files either shared or based on user type
"""
conn = sqlite3.connect(WORKING_DATABASE)
cursor = conn.cursor()
# Construct the SQL query with JOINs for Subject, Topic, and Users tables
if st.session_state.user['profile_id'] == 'SA':
cursor.execute('''
SELECT Files.file_id, Files.file_name, Subject.subject_name, Topic.topic_name, Users.username
FROM Files
JOIN Subject ON Files.subject = Subject.id
JOIN Topic ON Files.topic = Topic.id
JOIN Users ON Files.user_id = Users.user_id
''')
else:
cursor.execute('''
SELECT Files.file_id, Files.file_name, Subject.subject_name, Topic.topic_name, Users.username
FROM Files
JOIN Subject ON Files.subject = Subject.id
JOIN Topic ON Files.topic = Topic.id
JOIN Users ON Files.user_id = Users.user_id
WHERE Files.sharing_enabled = 1
''')
files = cursor.fetchall()
formatted_files = [f"({file[0]}) {file[1]} ({file[4]})" for file in files]
conn.close()
return formatted_files
def fetch_file_data(file_id):
"""
Fetch file data given a file id
"""
conn = sqlite3.connect(WORKING_DATABASE)
cursor = conn.cursor()
cursor.execute("SELECT data, metadata FROM Files WHERE file_id = ?", (file_id,))
data = cursor.fetchone()
conn.close()
if data:
return data[0], data[1]
else:
return None, None
def fetch_subjects_by_org(org_id):
conn = sqlite3.connect(WORKING_DATABASE)
cursor = conn.cursor()
# Check if the user is a super_admin (org_id is 0)
if org_id == 0:
cursor.execute('SELECT * FROM Subject;')
else:
cursor.execute('SELECT * FROM Subject WHERE org_id = ?;', (org_id,))
subjects = cursor.fetchall()
conn.close()
return subjects
def fetch_topics_by_org(org_id):
conn = sqlite3.connect(WORKING_DATABASE)
cursor = conn.cursor()
# Check if the user is a super_admin (org_id is 0)
if org_id == 0:
cursor.execute('SELECT * FROM Topic;')
else:
cursor.execute('SELECT * FROM Topic WHERE org_id = ?;', (org_id,))
topics = cursor.fetchall()
conn.close()
return topics
def split_docs(file_path,meta):
#def split_meta_docs(file, source, tch_code):
loader = UnstructuredFileLoader(file_path)
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
docs = text_splitter.split_documents(documents)
metadata = {"source": meta}
for doc in docs:
doc.metadata.update(metadata)
return docs
def create_lancedb_table(embeddings, meta, table_name):
lancedb_path = os.path.join(WORKING_DIRECTORY, "lancedb")
# LanceDB connection
db = lancedb.connect(lancedb_path)
table = db.create_table(
f"{table_name}",
data=[
{
"vector": embeddings.embed_query("Query Unsuccessful"),
"text": "Query Unsuccessful",
"id": "1",
"source": f"{meta}"
}
],
mode="overwrite",
)
return table
def save_to_vectorstores(vs, vstore_input_name, subject, topic, username, share_resource=False):
conn = sqlite3.connect(WORKING_DATABASE)
cursor = conn.cursor()
# Fetch the user's details
cursor.execute('SELECT user_id FROM Users WHERE username = ?', (username,))
user_details = cursor.fetchone()
if not user_details:
st.error("Error: User not found.")
return
user_id = user_details[0]
# If Vector_Store instance exists in session state, then serialize and save
if vs:
serialized_db = pickle.dumps(vs)
# Check if the entry already exists
cursor.execute('SELECT 1 FROM Vector_Stores WHERE vectorstore_name LIKE ? AND user_id = ?', (f"%{vstore_input_name}%", user_id))
exists = cursor.fetchone()
if exists:
st.error("Error: An entry with the same vectorstore_name and user_id already exists.")
return
if subject is None:
st.error("Error: Function is missing.")
return
if topic is None:
st.error("Error: Process is missing.")
return
# Get the subject and topic IDs
cursor.execute('SELECT id FROM Subject WHERE subject_name = ?', (subject,))
subject_id = cursor.fetchone()[0]
cursor.execute('SELECT id FROM Topic WHERE topic_name = ?', (topic,))
topic_id = cursor.fetchone()[0]
# Insert the new row
cursor.execute('''
INSERT INTO Vector_Stores (vectorstore_name, data, user_id, subject, topic, sharing_enabled)
VALUES (?, ?, ?, ?, ?, ?)
''', (vstore_input_name, serialized_db, user_id, subject_id, topic_id, share_resource))
conn.commit()
conn.close()
def create_vectorstore():
full_docs = []
st.subheader("Enter the process and functions for your knowledge base")
embeddings = OpenAIEmbeddings()
# Fetch all available subjects
subjects = fetch_subjects_by_org(st.session_state.user["org_id"])
subject_names = [sub[2] for sub in subjects] # Assuming index 2 holds the subject_name
selected_subject = st.selectbox("Select an existing function or type a new one:", options=subject_names + ['New Function'])
if selected_subject == 'New Function':
subject = st.text_input("Please enter the new function name:", max_chars=30)
else:
subject = selected_subject
# Fetch all available topics
topics = fetch_topics_by_org(st.session_state.user["org_id"])
topic_names = [topic[2] for topic in topics] # Assuming index 2 holds the topic_name
selected_topic = st.selectbox("Select an existing process or type a new one:", options=topic_names + ['New Process'])
if selected_topic == 'New Process':
topic = st.text_input("Please enter the new process name:", max_chars=30)
else:
topic = selected_topic
vectorstore_input = st.text_input("Please type in a name for your knowledge base:", max_chars=20)
vs_name = vectorstore_input + f"_({st.session_state.user['username']})"
share_resource = st.checkbox("Share this resource", value=True) # <-- Added this line
# Show the current build of files for the latest database
st.subheader("Select one or more files to build your knowledge base")
files = fetch_all_files()
if files:
selected_files = sac.transfer(items=files, label=None, index=None, titles=['Uploaded files', 'Select files for KB'], format_func='title', width='100%', height=None, search=True, pagination=False, oneway=False, reload=True, disabled=False, return_index=False)
# Alert to confirm the creation of knowledge base
st.warning("Building your knowledge base will take some time. Please be patient.")
build = sac.buttons([
dict(label='Build VectorStore', icon='check-circle-fill', color = 'green'),
dict(label='Cancel', icon='x-circle-fill', color='red'),
], label=None, index=1, format_func='title', align='center', position='top', size='default', direction='horizontal', shape='round', type='default', compact=False, return_index=False)
if build == 'Build VectorStore' and selected_files:
for s_file in selected_files:
file_id = int(s_file.split("(", 1)[1].split(")", 1)[0])
file_data, meta = fetch_file_data(file_id)
docs = split_docs(file_data, meta)
full_docs.extend(docs)
db = LanceDB.from_documents(full_docs, OpenAIEmbeddings(), connection=create_lancedb_table(embeddings, meta, vs_name))
save_to_vectorstores(db, vs_name, subject, topic, st.session_state.user["username"], share_resource) # Passing the share_resource to the function
st.success("Knowledge Base loaded")
else:
st.write("No files found in the database.")
def delete_lancedb_table(table_name):
lancedb_path = os.path.join(WORKING_DIRECTORY, "lancedb")
# LanceDB connection
db = lancedb.connect(lancedb_path)
db.drop_table(f"{table_name}")
def fetch_vectorstores_by_user_id(user_id):
conn = sqlite3.connect(WORKING_DATABASE)
cursor = conn.cursor()
# Fetch vectorstores based on user_id
cursor.execute('SELECT vectorstore_name FROM Vector_Stores WHERE user_id = ?;', (user_id,))
vectorstores = cursor.fetchall()
conn.close()
return vectorstores
def delete_vectorstores():
st.subheader("Delete Knowledge Base in Database:")
user_vectorstores = fetch_vectorstores_by_user_id(st.session_state.user["id"])
if user_vectorstores:
vectorstore_names = [vs[0] for vs in user_vectorstores]
selected_vectorstores = st.multiselect("Select knowledge bases to delete:", options=vectorstore_names)
confirm_delete = st.checkbox("I understand that this action cannot be undone.", value=False)
if st.button("Delete VectorStore"):
if confirm_delete and selected_vectorstores:
delete_vectorstores_from_db(selected_vectorstores, st.session_state.user["id"], st.session_state.user["profile_id"])
st.success(f"Deleted {len(selected_vectorstores)} vectorstores.")
else:
st.warning("Please confirm the deletion action.")
else:
st.write("No knowledge base found in the database.")
def delete_vectorstores_from_db(vectorstore_names, user_id, profile):
conn = sqlite3.connect(WORKING_DATABASE)
cursor = conn.cursor()
for vectorstore_name in vectorstore_names:
if profile in ['SA', 'AD']:
# Delete the corresponding LanceDB table
delete_lancedb_table(vectorstore_name)
# Delete vectorstore irrespective of the user_id associated with them
cursor.execute('DELETE FROM Vector_Stores WHERE vectorstore_name=?;', (vectorstore_name,))
else:
# Delete the corresponding LanceDB table
delete_lancedb_table(vectorstore_name)
# Delete only if the user_id matches
cursor.execute('DELETE FROM Vector_Stores WHERE vectorstore_name=? AND user_id=?;', (vectorstore_name, user_id))
# Check if the row was affected
if cursor.rowcount == 0:
st.error(f"Unable to delete knowledge base '{vectorstore_name}' that is not owned by you.")
conn.commit() # Commit the changes
conn.close() # Close the connection
| [
"lancedb.connect"
] | [((1234, 1245), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1243, 1245), False, 'import os\n'), ((1266, 1295), 'os.path.join', 'os.path.join', (['cwd', '"""database"""'], {}), "(cwd, 'database')\n", (1278, 1295), False, 'import os\n'), ((1304, 1337), 'os.path.exists', 'os.path.exists', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (1318, 1337), False, 'import os\n'), ((1340, 1370), 'os.makedirs', 'os.makedirs', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (1351, 1370), False, 'import os\n'), ((1432, 1489), 'os.path.join', 'os.path.join', (['WORKING_DIRECTORY', "st.secrets['default_db']"], {}), "(WORKING_DIRECTORY, st.secrets['default_db'])\n", (1444, 1489), False, 'import os\n'), ((1596, 1629), 'sqlite3.connect', 'sqlite3.connect', (['WORKING_DATABASE'], {}), '(WORKING_DATABASE)\n', (1611, 1629), False, 'import sqlite3\n'), ((2261, 2377), 'pandas.DataFrame', 'pd.DataFrame', (['data'], {'columns': "['KB ID', 'Function Name', 'Process Name', 'KB Name', 'Username',\n 'sharing_enabled']"}), "(data, columns=['KB ID', 'Function Name', 'Process Name',\n 'KB Name', 'Username', 'sharing_enabled'])\n", (2273, 2377), True, 'import pandas as pd\n'), ((2512, 2657), 'streamlit.dataframe', 'st.dataframe', (['df'], {'use_container_width': '(True)', 'column_order': "['KB ID', 'Function Name', 'Process Name', 'KB Name', 'Username',\n 'sharing_enabled']"}), "(df, use_container_width=True, column_order=['KB ID',\n 'Function Name', 'Process Name', 'KB Name', 'Username', 'sharing_enabled'])\n", (2524, 2657), True, 'import streamlit as st\n'), ((2792, 2825), 'sqlite3.connect', 'sqlite3.connect', (['WORKING_DATABASE'], {}), '(WORKING_DATABASE)\n', (2807, 2825), False, 'import sqlite3\n'), ((3967, 4000), 'sqlite3.connect', 'sqlite3.connect', (['WORKING_DATABASE'], {}), '(WORKING_DATABASE)\n', (3982, 4000), False, 'import sqlite3\n'), ((4293, 4326), 'sqlite3.connect', 'sqlite3.connect', (['WORKING_DATABASE'], {}), '(WORKING_DATABASE)\n', (4308, 4326), False, 'import sqlite3\n'), ((4687, 4720), 'sqlite3.connect', 'sqlite3.connect', (['WORKING_DATABASE'], {}), '(WORKING_DATABASE)\n', (4702, 4720), False, 'import sqlite3\n'), ((5116, 5149), 'langchain.document_loaders.UnstructuredFileLoader', 'UnstructuredFileLoader', (['file_path'], {}), '(file_path)\n', (5138, 5149), False, 'from langchain.document_loaders import UnstructuredFileLoader\n'), ((5194, 5249), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(0)'}), '(chunk_size=1000, chunk_overlap=0)\n', (5215, 5249), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((5464, 5506), 'os.path.join', 'os.path.join', (['WORKING_DIRECTORY', '"""lancedb"""'], {}), "(WORKING_DIRECTORY, 'lancedb')\n", (5476, 5506), False, 'import os\n'), ((5535, 5564), 'lancedb.connect', 'lancedb.connect', (['lancedb_path'], {}), '(lancedb_path)\n', (5550, 5564), False, 'import lancedb\n'), ((5914, 5947), 'sqlite3.connect', 'sqlite3.connect', (['WORKING_DATABASE'], {}), '(WORKING_DATABASE)\n', (5929, 5947), False, 'import sqlite3\n'), ((7603, 7674), 'streamlit.subheader', 'st.subheader', (['"""Enter the process and functions for your knowledge base"""'], {}), "('Enter the process and functions for your knowledge base')\n", (7615, 7674), True, 'import streamlit as st\n'), ((7692, 7710), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (7708, 7710), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((7932, 8041), 'streamlit.selectbox', 'st.selectbox', (['"""Select an existing function or type a new one:"""'], {'options': "(subject_names + ['New Function'])"}), "('Select an existing function or type a new one:', options=\n subject_names + ['New Function'])\n", (7944, 8041), True, 'import streamlit as st\n'), ((8426, 8531), 'streamlit.selectbox', 'st.selectbox', (['"""Select an existing process or type a new one:"""'], {'options': "(topic_names + ['New Process'])"}), "('Select an existing process or type a new one:', options=\n topic_names + ['New Process'])\n", (8438, 8531), True, 'import streamlit as st\n'), ((8724, 8801), 'streamlit.text_input', 'st.text_input', (['"""Please type in a name for your knowledge base:"""'], {'max_chars': '(20)'}), "('Please type in a name for your knowledge base:', max_chars=20)\n", (8737, 8801), True, 'import streamlit as st\n'), ((8899, 8945), 'streamlit.checkbox', 'st.checkbox', (['"""Share this resource"""'], {'value': '(True)'}), "('Share this resource', value=True)\n", (8910, 8945), True, 'import streamlit as st\n'), ((9036, 9105), 'streamlit.subheader', 'st.subheader', (['"""Select one or more files to build your knowledge base"""'], {}), "('Select one or more files to build your knowledge base')\n", (9048, 9105), True, 'import streamlit as st\n'), ((10774, 10816), 'os.path.join', 'os.path.join', (['WORKING_DIRECTORY', '"""lancedb"""'], {}), "(WORKING_DIRECTORY, 'lancedb')\n", (10786, 10816), False, 'import os\n'), ((10845, 10874), 'lancedb.connect', 'lancedb.connect', (['lancedb_path'], {}), '(lancedb_path)\n', (10860, 10874), False, 'import lancedb\n'), ((10963, 10996), 'sqlite3.connect', 'sqlite3.connect', (['WORKING_DATABASE'], {}), '(WORKING_DATABASE)\n', (10978, 10996), False, 'import sqlite3\n'), ((11282, 11332), 'streamlit.subheader', 'st.subheader', (['"""Delete Knowledge Base in Database:"""'], {}), "('Delete Knowledge Base in Database:')\n", (11294, 11332), True, 'import streamlit as st\n'), ((12285, 12318), 'sqlite3.connect', 'sqlite3.connect', (['WORKING_DATABASE'], {}), '(WORKING_DATABASE)\n', (12300, 12318), False, 'import sqlite3\n'), ((456, 483), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (481, 483), False, 'import configparser\n'), ((6158, 6192), 'streamlit.error', 'st.error', (['"""Error: User not found."""'], {}), "('Error: User not found.')\n", (6166, 6192), True, 'import streamlit as st\n'), ((6355, 6371), 'pickle.dumps', 'pickle.dumps', (['vs'], {}), '(vs)\n', (6367, 6371), False, 'import pickle\n'), ((8103, 8169), 'streamlit.text_input', 'st.text_input', (['"""Please enter the new function name:"""'], {'max_chars': '(30)'}), "('Please enter the new function name:', max_chars=30)\n", (8116, 8169), True, 'import streamlit as st\n'), ((8588, 8653), 'streamlit.text_input', 'st.text_input', (['"""Please enter the new process name:"""'], {'max_chars': '(30)'}), "('Please enter the new process name:', max_chars=30)\n", (8601, 8653), True, 'import streamlit as st\n'), ((9175, 9429), 'streamlit_antd_components.transfer', 'sac.transfer', ([], {'items': 'files', 'label': 'None', 'index': 'None', 'titles': "['Uploaded files', 'Select files for KB']", 'format_func': '"""title"""', 'width': '"""100%"""', 'height': 'None', 'search': '(True)', 'pagination': '(False)', 'oneway': '(False)', 'reload': '(True)', 'disabled': '(False)', 'return_index': '(False)'}), "(items=files, label=None, index=None, titles=['Uploaded files',\n 'Select files for KB'], format_func='title', width='100%', height=None,\n search=True, pagination=False, oneway=False, reload=True, disabled=\n False, return_index=False)\n", (9187, 9429), True, 'import streamlit_antd_components as sac\n'), ((9492, 9579), 'streamlit.warning', 'st.warning', (['"""Building your knowledge base will take some time. Please be patient."""'], {}), "(\n 'Building your knowledge base will take some time. Please be patient.')\n", (9502, 9579), True, 'import streamlit as st\n'), ((10674, 10717), 'streamlit.write', 'st.write', (['"""No files found in the database."""'], {}), "('No files found in the database.')\n", (10682, 10717), True, 'import streamlit as st\n'), ((11543, 11621), 'streamlit.multiselect', 'st.multiselect', (['"""Select knowledge bases to delete:"""'], {'options': 'vectorstore_names'}), "('Select knowledge bases to delete:', options=vectorstore_names)\n", (11557, 11621), True, 'import streamlit as st\n'), ((11647, 11722), 'streamlit.checkbox', 'st.checkbox', (['"""I understand that this action cannot be undone."""'], {'value': '(False)'}), "('I understand that this action cannot be undone.', value=False)\n", (11658, 11722), True, 'import streamlit as st\n'), ((11743, 11774), 'streamlit.button', 'st.button', (['"""Delete VectorStore"""'], {}), "('Delete VectorStore')\n", (11752, 11774), True, 'import streamlit as st\n'), ((12150, 12202), 'streamlit.write', 'st.write', (['"""No knowledge base found in the database."""'], {}), "('No knowledge base found in the database.')\n", (12158, 12202), True, 'import streamlit as st\n'), ((722, 745), 'ast.literal_eval', 'ast.literal_eval', (['value'], {}), '(value)\n', (738, 745), False, 'import ast\n'), ((6621, 6717), 'streamlit.error', 'st.error', (['"""Error: An entry with the same vectorstore_name and user_id already exists."""'], {}), "(\n 'Error: An entry with the same vectorstore_name and user_id already exists.'\n )\n", (6629, 6717), True, 'import streamlit as st\n'), ((6776, 6815), 'streamlit.error', 'st.error', (['"""Error: Function is missing."""'], {}), "('Error: Function is missing.')\n", (6784, 6815), True, 'import streamlit as st\n'), ((6874, 6912), 'streamlit.error', 'st.error', (['"""Error: Process is missing."""'], {}), "('Error: Process is missing.')\n", (6882, 6912), True, 'import streamlit as st\n'), ((10619, 10654), 'streamlit.success', 'st.success', (['"""Knowledge Base loaded"""'], {}), "('Knowledge Base loaded')\n", (10629, 10654), True, 'import streamlit as st\n'), ((10367, 10385), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (10383, 10385), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((12082, 12131), 'streamlit.warning', 'st.warning', (['"""Please confirm the deletion action."""'], {}), "('Please confirm the deletion action.')\n", (12092, 12131), True, 'import streamlit as st\n'), ((13147, 13248), 'streamlit.error', 'st.error', (['f"""Unable to delete knowledge base \'{vectorstore_name}\' that is not owned by you."""'], {}), '(\n f"Unable to delete knowledge base \'{vectorstore_name}\' that is not owned by you."\n )\n', (13155, 13248), True, 'import streamlit as st\n')] |
# retrivel from PDF
import os
import sys
from pydantic import BaseModel, Field
from langchain.chat_models import AzureChatOpenAI
from langchain.embeddings import AzureOpenAIEmbeddings
from langchain.chains import LLMChain, HypotheticalDocumentEmbedder
from langchain.prompts import PromptTemplate
from langchain.embeddings import HuggingFaceEmbeddings
from openai import AzureOpenAI
# Get the directory of the current script
current_script_dir = os.path.dirname(os.path.abspath(__file__))
# Get the parent directory (applied_rag) by navigating up one level from the current script
parent_dir = os.path.dirname(current_script_dir)
# Add the parent directory to sys.path
sys.path.append(parent_dir)
import settings
from langchain.vectorstores import LanceDB
import lancedb
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader
# Configuration data class
class AppConfig(BaseModel):
openai_api_key: str
openai_api_base: str
openai_api_type: str
deployment_name: str
model_name: str
openai_api_version: str
# Load configuration from settings
config = AppConfig(
openai_api_key=settings.openai_api_key,
openai_api_base=settings.openai_api_base,
openai_api_type=settings.openai_api_type,
deployment_name=settings.deployment_name,
model_name=settings.model_name,
openai_api_version=settings.openai_api_version
)
# Initialize Azure LLM
llm = AzureChatOpenAI(
deployment_name=config.deployment_name,
openai_api_key=config.openai_api_key,
openai_api_base=config.openai_api_base,
openai_api_type=config.openai_api_type,
openai_api_version=config.openai_api_version,
model_name=config.model_name,
temperature=0.0
)
emebeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
embeddings = HypotheticalDocumentEmbedder.from_llm(llm, emebeddings, "web_search")
prompt_template = """
As a knowledgeable and helpful research assistant, your task is to provide informative answers based on the given context. Use your extensive knowledge base to offer clear, concise, and accurate responses to the user's inquiries.
if quetion is not related to documents simply say you dont know
Question: {question}
Answer:
"""
prompt = PromptTemplate(input_variables=["question"], template=prompt_template)
llm_chain = LLMChain(llm=llm, prompt=prompt)
embeddings = HypotheticalDocumentEmbedder(
llm_chain=llm_chain,
base_embeddings=embeddings
)
# Loading data from pdf
pdf_folder_path = '/workspaces/rag/02_Hyde/pamphlet.pdf'
loader = PyPDFLoader(pdf_folder_path)
docs = loader.load_and_split()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=128,
chunk_overlap=50,
)
documents = text_splitter.split_documents(docs)
# lancedb as vectorstore
db = lancedb.connect('/tmp/lancedb')
table = db.create_table("documentsai", data=[
{"vector": embeddings.embed_query("アジャイル"), "text": "アジャイル", "id": "1"}
], mode="overwrite")
vector_store = LanceDB.from_documents(documents, embeddings, connection=table)
# passing in the string query to get some refrence
# query = "which factors appear to be the major nutritional limitations of fast-food meals"
query = "Ridgelinezアジャイルサービスとその優位性を説明してください。"
# result = vector_store.similarity_search(query)
# print(result)
answer = llm_chain.run(query)
print(answer) | [
"lancedb.connect"
] | [((596, 631), 'os.path.dirname', 'os.path.dirname', (['current_script_dir'], {}), '(current_script_dir)\n', (611, 631), False, 'import os\n'), ((672, 699), 'sys.path.append', 'sys.path.append', (['parent_dir'], {}), '(parent_dir)\n', (687, 699), False, 'import sys\n'), ((1453, 1733), 'langchain.chat_models.AzureChatOpenAI', 'AzureChatOpenAI', ([], {'deployment_name': 'config.deployment_name', 'openai_api_key': 'config.openai_api_key', 'openai_api_base': 'config.openai_api_base', 'openai_api_type': 'config.openai_api_type', 'openai_api_version': 'config.openai_api_version', 'model_name': 'config.model_name', 'temperature': '(0.0)'}), '(deployment_name=config.deployment_name, openai_api_key=\n config.openai_api_key, openai_api_base=config.openai_api_base,\n openai_api_type=config.openai_api_type, openai_api_version=config.\n openai_api_version, model_name=config.model_name, temperature=0.0)\n', (1468, 1733), False, 'from langchain.chat_models import AzureChatOpenAI\n'), ((1765, 1817), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""all-MiniLM-L6-v2"""'}), "(model_name='all-MiniLM-L6-v2')\n", (1786, 1817), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n'), ((1832, 1901), 'langchain.chains.HypotheticalDocumentEmbedder.from_llm', 'HypotheticalDocumentEmbedder.from_llm', (['llm', 'emebeddings', '"""web_search"""'], {}), "(llm, emebeddings, 'web_search')\n", (1869, 1901), False, 'from langchain.chains import LLMChain, HypotheticalDocumentEmbedder\n'), ((2264, 2334), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['question']", 'template': 'prompt_template'}), "(input_variables=['question'], template=prompt_template)\n", (2278, 2334), False, 'from langchain.prompts import PromptTemplate\n'), ((2348, 2380), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (2356, 2380), False, 'from langchain.chains import LLMChain, HypotheticalDocumentEmbedder\n'), ((2394, 2471), 'langchain.chains.HypotheticalDocumentEmbedder', 'HypotheticalDocumentEmbedder', ([], {'llm_chain': 'llm_chain', 'base_embeddings': 'embeddings'}), '(llm_chain=llm_chain, base_embeddings=embeddings)\n', (2422, 2471), False, 'from langchain.chains import LLMChain, HypotheticalDocumentEmbedder\n'), ((2574, 2602), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['pdf_folder_path'], {}), '(pdf_folder_path)\n', (2585, 2602), False, 'from langchain.document_loaders import PyPDFLoader\n'), ((2651, 2715), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(128)', 'chunk_overlap': '(50)'}), '(chunk_size=128, chunk_overlap=50)\n', (2681, 2715), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((2808, 2839), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (2823, 2839), False, 'import lancedb\n'), ((2998, 3061), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['documents', 'embeddings'], {'connection': 'table'}), '(documents, embeddings, connection=table)\n', (3020, 3061), False, 'from langchain.vectorstores import LanceDB\n'), ((463, 488), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (478, 488), False, 'import os\n')] |
from langchain.document_loaders import TextLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.document_loaders import UnstructuredMarkdownLoader
from langchain.document_loaders import DirectoryLoader
from langchain.chat_models.fireworks import ChatFireworks
from langchain.vectorstores import LanceDB
from langchain.chat_models import ChatOpenAI
from langchain.callbacks import StdOutCallbackHandler
import lancedb
handler = StdOutCallbackHandler()
from langchain.agents.agent_toolkits import (
create_vectorstore_agent,
VectorStoreToolkit,
VectorStoreInfo,
)
# llm = ChatFireworks(model="accounts/fireworks/models/mistral-7b", temperature=0)
llm = ChatOpenAI(temperature=0)
db = lancedb.connect(".lance-data")
table = db.open_table("journal")
db = LanceDB(table, OpenAIEmbeddings())
vectorstore_info = VectorStoreInfo(
name="flancian's journal",
description="collection of markdown files containing flancian's daily journal",
vectorstore=db,
)
toolkit = VectorStoreToolkit(vectorstore_info=vectorstore_info)
def run_engine(prompt):
agent_executor = create_vectorstore_agent(
llm=llm, toolkit=toolkit, verbose=True, prefix="always use sources"
)
resp = agent_executor.run(
input=prompt,
)
return resp
| [
"lancedb.connect"
] | [((554, 577), 'langchain.callbacks.StdOutCallbackHandler', 'StdOutCallbackHandler', ([], {}), '()\n', (575, 577), False, 'from langchain.callbacks import StdOutCallbackHandler\n'), ((793, 818), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)'}), '(temperature=0)\n', (803, 818), False, 'from langchain.chat_models import ChatOpenAI\n'), ((824, 854), 'lancedb.connect', 'lancedb.connect', (['""".lance-data"""'], {}), "('.lance-data')\n", (839, 854), False, 'import lancedb\n'), ((949, 1096), 'langchain.agents.agent_toolkits.VectorStoreInfo', 'VectorStoreInfo', ([], {'name': '"""flancian\'s journal"""', 'description': '"""collection of markdown files containing flancian\'s daily journal"""', 'vectorstore': 'db'}), '(name="flancian\'s journal", description=\n "collection of markdown files containing flancian\'s daily journal",\n vectorstore=db)\n', (964, 1096), False, 'from langchain.agents.agent_toolkits import create_vectorstore_agent, VectorStoreToolkit, VectorStoreInfo\n'), ((1114, 1167), 'langchain.agents.agent_toolkits.VectorStoreToolkit', 'VectorStoreToolkit', ([], {'vectorstore_info': 'vectorstore_info'}), '(vectorstore_info=vectorstore_info)\n', (1132, 1167), False, 'from langchain.agents.agent_toolkits import create_vectorstore_agent, VectorStoreToolkit, VectorStoreInfo\n'), ((908, 926), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (924, 926), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((1215, 1313), 'langchain.agents.agent_toolkits.create_vectorstore_agent', 'create_vectorstore_agent', ([], {'llm': 'llm', 'toolkit': 'toolkit', 'verbose': '(True)', 'prefix': '"""always use sources"""'}), "(llm=llm, toolkit=toolkit, verbose=True, prefix=\n 'always use sources')\n", (1239, 1313), False, 'from langchain.agents.agent_toolkits import create_vectorstore_agent, VectorStoreToolkit, VectorStoreInfo\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
from llama_index.data_structs.node import DocumentRelationship, Node
from llama_index.vector_stores.types import (
NodeWithEmbedding,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb # noqa: F401
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return None
def add(
self,
embedding_results: List[NodeWithEmbedding],
) -> List[str]:
data = []
ids = []
for result in embedding_results:
data.append(
{
"id": result.id,
"doc_id": result.ref_doc_id,
"vector": result.embedding,
"text": result.node.get_text(),
}
)
ids.append(result.id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
raise NotImplementedError("Delete not yet implemented for LanceDB.")
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
raise ValueError("Metadata filters not implemented for LanceDB yet.")
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = Node(
doc_id=item.id,
text=item.text,
relationships={
DocumentRelationship.SOURCE: item.doc_id,
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=results["score"].tolist(),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((1711, 1731), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (1726, 1731), False, 'import lancedb\n'), ((3712, 3811), 'llama_index.data_structs.node.Node', 'Node', ([], {'doc_id': 'item.id', 'text': 'item.text', 'relationships': '{DocumentRelationship.SOURCE: item.doc_id}'}), '(doc_id=item.id, text=item.text, relationships={DocumentRelationship.\n SOURCE: item.doc_id})\n', (3716, 3811), False, 'from llama_index.data_structs.node import DocumentRelationship, Node\n')] |
import streamlit as st
import docx2txt
import fitz
import os
from langchain.text_splitter import CharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from dotenv import load_dotenv
from pathlib import Path
from langchain_community.vectorstores import LanceDB
import lancedb
import os
load_dotenv()
env_path = Path('.')/'.env'
load_dotenv(dotenv_path=env_path)
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
def connect_table(database):
try:
if database == 'lancedb':
db = lancedb.connect("~/.lancedb")
return db
except Exception as e:
return st.error(f"Error during LanceDB operations: {e}")
def create_table(db):
table = db.create_table(
"recipes",
data=[
{
"vector": OpenAIEmbeddings().embed_query("Recipes"),
"text": "Recipes",
}
],
mode="overwrite",
)
return table
def store_embeddings(content, document_title):
try:
db = connect_table("lancedb")
table = create_table(db)
documents = character_text_splitter(content, document_title)
docsearch = LanceDB.from_documents(documents, OpenAIEmbeddings(), connection=table)
if "sharedsearch" not in st.session_state:
st.session_state["sharedsearch"] = docsearch
query = "Get METHOD for Aloo Palak"
# ->>>> similarity_search
docs = docsearch.similarity_search(query, k=1, score=True)
st.write(docs)
# ->>>> similarity_search_by_vector
# embedding_vector = OpenAIEmbeddings().embed_query(query)
# docs = docsearch.max_marginal_relevance_search(embedding_vector, k=2, fetch_k=10)
# found_docs = docs.amax_marginal_relevance_search(query, k=2, fetch_k=10)
# for i, doc in enumerate(found_docs):
# print(f"{i + 1}.", doc.page_content, "\n")
return docs
except FileNotFoundError as e:
st.error(f"Error while Storing Embeddings: {e}")
def read_docx(file_path):
text = docx2txt.process(file_path)
return text
def read_pdf(file_path):
if not os.path.exists(file_path):
raise FileNotFoundError(f"PDF file not found at: {file_path}")
pdf_document = fitz.open(file_path)
text = ""
for page_num in range(len(pdf_document)):
page = pdf_document[page_num]
text += page.get_text()
return text
def read_file(file):
content = ""
if file.type == "application/pdf":
try:
content = read_pdf(file.name)
except FileNotFoundError as e:
st.error(f"Error reading PDF file: {e}")
elif file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
content = read_docx(file)
formatted_text = content.upper()
return formatted_text
def character_text_splitter(content, document_title):
text_splitter = CharacterTextSplitter(
separator="\n\n\t\t",
chunk_size=1000,
chunk_overlap=200,
length_function=len,
is_separator_regex=False,
keep_separator=True
)
metadatas = [{"title": document_title}]
documents = text_splitter.create_documents([content], metadatas=metadatas)
return documents
def main():
st.markdown("# File Upload")
st.sidebar.markdown("# File Upload")
document_title = st.text_input("Enter the document title:")
uploaded_file = st.file_uploader("Upload a document (doc, pdf) or provide a link", type=["docx", "pdf"])
if uploaded_file is not None:
try:
content = read_file(uploaded_file)
documents = store_embeddings(content, document_title)
st.write("### Content:")
st.write(documents)
except FileNotFoundError as e:
st.error(f"Error reading content from the uploaded file: {e}")
if __name__ == "__main__":
main()
| [
"lancedb.connect"
] | [((302, 315), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (313, 315), False, 'from dotenv import load_dotenv\n'), ((344, 377), 'dotenv.load_dotenv', 'load_dotenv', ([], {'dotenv_path': 'env_path'}), '(dotenv_path=env_path)\n', (355, 377), False, 'from dotenv import load_dotenv\n'), ((396, 423), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (405, 423), False, 'import os\n'), ((327, 336), 'pathlib.Path', 'Path', (['"""."""'], {}), "('.')\n", (331, 336), False, 'from pathlib import Path\n'), ((2044, 2071), 'docx2txt.process', 'docx2txt.process', (['file_path'], {}), '(file_path)\n', (2060, 2071), False, 'import docx2txt\n'), ((2243, 2263), 'fitz.open', 'fitz.open', (['file_path'], {}), '(file_path)\n', (2252, 2263), False, 'import fitz\n'), ((2910, 3062), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'separator': '"""\n\n\t\t"""', 'chunk_size': '(1000)', 'chunk_overlap': '(200)', 'length_function': 'len', 'is_separator_regex': '(False)', 'keep_separator': '(True)'}), "(separator='\\n\\n\\t\\t', chunk_size=1000, chunk_overlap=\n 200, length_function=len, is_separator_regex=False, keep_separator=True)\n", (2931, 3062), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((3275, 3303), 'streamlit.markdown', 'st.markdown', (['"""# File Upload"""'], {}), "('# File Upload')\n", (3286, 3303), True, 'import streamlit as st\n'), ((3308, 3344), 'streamlit.sidebar.markdown', 'st.sidebar.markdown', (['"""# File Upload"""'], {}), "('# File Upload')\n", (3327, 3344), True, 'import streamlit as st\n'), ((3367, 3409), 'streamlit.text_input', 'st.text_input', (['"""Enter the document title:"""'], {}), "('Enter the document title:')\n", (3380, 3409), True, 'import streamlit as st\n'), ((3430, 3523), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload a document (doc, pdf) or provide a link"""'], {'type': "['docx', 'pdf']"}), "('Upload a document (doc, pdf) or provide a link', type=[\n 'docx', 'pdf'])\n", (3446, 3523), True, 'import streamlit as st\n'), ((1487, 1501), 'streamlit.write', 'st.write', (['docs'], {}), '(docs)\n', (1495, 1501), True, 'import streamlit as st\n'), ((2125, 2150), 'os.path.exists', 'os.path.exists', (['file_path'], {}), '(file_path)\n', (2139, 2150), False, 'import os\n'), ((514, 543), 'lancedb.connect', 'lancedb.connect', (['"""~/.lancedb"""'], {}), "('~/.lancedb')\n", (529, 543), False, 'import lancedb\n'), ((604, 653), 'streamlit.error', 'st.error', (['f"""Error during LanceDB operations: {e}"""'], {}), "(f'Error during LanceDB operations: {e}')\n", (612, 653), True, 'import streamlit as st\n'), ((1185, 1203), 'langchain_openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (1201, 1203), False, 'from langchain_openai import OpenAIEmbeddings\n'), ((1957, 2005), 'streamlit.error', 'st.error', (['f"""Error while Storing Embeddings: {e}"""'], {}), "(f'Error while Storing Embeddings: {e}')\n", (1965, 2005), True, 'import streamlit as st\n'), ((3692, 3716), 'streamlit.write', 'st.write', (['"""### Content:"""'], {}), "('### Content:')\n", (3700, 3716), True, 'import streamlit as st\n'), ((3729, 3748), 'streamlit.write', 'st.write', (['documents'], {}), '(documents)\n', (3737, 3748), True, 'import streamlit as st\n'), ((2595, 2635), 'streamlit.error', 'st.error', (['f"""Error reading PDF file: {e}"""'], {}), "(f'Error reading PDF file: {e}')\n", (2603, 2635), True, 'import streamlit as st\n'), ((3800, 3862), 'streamlit.error', 'st.error', (['f"""Error reading content from the uploaded file: {e}"""'], {}), "(f'Error reading content from the uploaded file: {e}')\n", (3808, 3862), True, 'import streamlit as st\n'), ((781, 799), 'langchain_openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (797, 799), False, 'from langchain_openai import OpenAIEmbeddings\n')] |
## Abandoned approach by Sasha
from typing import List
import lancedb
from data_assessment_agent.config.config import cfg
from data_assessment_agent.model.vector_db_model import Questions
def connect_to_lance_questions():
db_file = cfg.lance_db_questions
db = lancedb.connect(db_file)
return db
lance_db_questions_db = connect_to_lance_questions()
def query_for_topic(topic: str, question: str, limit=5) -> List[str]:
table = lance_db_questions_db.open_table(topic)
results = table.search(question).limit(limit).to_pydantic(Questions)
return [r.question for r in results]
async def rank_questions(
topic: str, question_answers: str, ranking_questions: List[str]
) -> List[str]:
res = query_for_topic(topic, question_answers, limit=len(ranking_questions + 5))
return [r for r in res if r in ranking_questions]
if __name__ == "__main__":
from data_assessment_agent.test.provider.question_provider import (
create_question_answers,
)
question_answers = create_question_answers()
assert isinstance(question_answers, str)
| [
"lancedb.connect"
] | [((272, 296), 'lancedb.connect', 'lancedb.connect', (['db_file'], {}), '(db_file)\n', (287, 296), False, 'import lancedb\n'), ((1019, 1044), 'data_assessment_agent.test.provider.question_provider.create_question_answers', 'create_question_answers', ([], {}), '()\n', (1042, 1044), False, 'from data_assessment_agent.test.provider.question_provider import create_question_answers\n')] |
import os
import shutil
import tempfile
import lancedb
import pandas as pd
import numpy as np
import duckdb
from typing import Optional, List
from .data_load import load_batches, load_df
from .model import BaseEmbeddingModel
from .db import LabelsDB
from .settings import DEFAULT_TABLE_NAME, DB_BATCH_LOAD, DB_BATCH_SIZE
duckdb.sql(
"""
INSTALL sqlite;
LOAD sqlite;
"""
)
class VectorDB:
def __init__(
self,
db_path: str,
db: lancedb.DBConnection,
table: lancedb.table.Table,
model: BaseEmbeddingModel,
data_path: str,
) -> None:
self.db = db
self.model = model
self.tbl = table
self.data_path = data_path
self.labelsdb_path = os.path.join(db_path, "labels.db")
self.labelsdb = LabelsDB(self.labelsdb_path)
@staticmethod
def from_data_path(
data_path: str,
db_path: str,
model: BaseEmbeddingModel,
delete_existing=True,
batch_load: bool = DB_BATCH_LOAD,
batch_size: int = DB_BATCH_SIZE,
):
db = lancedb.connect(db_path)
table_name = DEFAULT_TABLE_NAME
if delete_existing and table_name in db.table_names():
print(f"Dropping existing database {table_name}...")
db.drop_table(table_name)
print("done.")
if table_name in db.table_names():
print(f'Opening existing table "{table_name}"...')
tbl = db.open_table(table_name)
return VectorDB(db_path, db, tbl, model, data_path)
else:
print(f'Creating table "{table_name}"...')
if batch_load:
tbl = load_batches(db, table_name, data_path, model, batch_size)
else:
tbl = load_df(db, table_name, data_path, model)
return VectorDB(db_path, db, tbl, model, data_path)
def count_rows(self) -> int:
return len(self.tbl)
def get(self, image_path: str) -> pd.DataFrame:
lance_tbl = self.tbl.to_lance()
return duckdb.sql(
f"SELECT * FROM lance_tbl WHERE image_path='{image_path}';"
).to_df()
def add_label(self, image_path: str, label: str):
self.labelsdb.add(image_path=image_path, label=label)
def remove_label(self, image_path: str, label: str):
self.labelsdb.remove(image_path=image_path, label=label)
def get_labels(self, image_path: Optional[str] = None) -> List[str]:
return self.labelsdb.get(image_path=image_path)
def get_label_counts(self) -> dict:
return self.labelsdb.counts()
def random_search(self, limit: int) -> pd.DataFrame:
lance_tbl = self.tbl.to_lance()
df_hits = duckdb.sql(
f"""
SELECT lance_tbl.*, grouped_labels.labels FROM lance_tbl
LEFT OUTER JOIN (
SELECT image_path, list(label) AS labels FROM sqlite_scan('{self.labelsdb_path}', 'labels') GROUP BY image_path
) AS grouped_labels
ON (lance_tbl.image_path = grouped_labels.image_path)
USING SAMPLE {limit} ROWS;
"""
).to_df()
df_hits["labels"] = df_hits["labels"].fillna("").apply(list)
df_hits.drop(columns=["vector"], inplace=True)
return df_hits
def search_by_image_path(
self, image_path: str, limit: int, exclude_labeled: bool
) -> pd.DataFrame:
full_image_path = os.path.join(self.data_path, image_path)
image_embedding = self.model.embed_image_path(full_image_path)
df_hits = self.__vector_embedding_search(
image_embedding,
limit,
exclude_image_path=image_path,
exclude_labeled=exclude_labeled,
)
return df_hits
def search_by_text(
self, query_string: str, limit: int, exclude_labeled: bool
) -> pd.DataFrame:
query_str_embedding = self.model.embed_text(query=query_string)
df_hits = self.__vector_embedding_search(
query_str_embedding, limit, exclude_labeled
)
return df_hits
def __vector_embedding_search(
self,
embedding: np.ndarray,
limit: int,
exclude_labeled: bool,
exclude_image_path: str = None,
) -> pd.DataFrame:
if exclude_labeled:
exclude_image_paths = set(self.labelsdb.get_image_paths())
else:
exclude_image_paths = set()
if exclude_image_path is not None:
exclude_image_paths.add(exclude_image_path)
if len(exclude_image_paths) == 0:
df_hits = self.tbl.search(embedding).limit(limit).to_df()
else:
exclude_image_paths_str = ",".join(
[f"'{image_path}'" for image_path in exclude_image_paths]
)
df_hits = (
self.tbl.search(embedding)
.where(f"image_path NOT IN ({exclude_image_paths_str})")
.limit(limit + len(exclude_image_paths))
.to_df()
)
df_hits = df_hits[0:limit]
df_hits.drop(columns=["vector"], inplace=True)
df_hits = self.__join_labels(left_table=df_hits)
return df_hits
def __join_labels(self, left_table: pd.DataFrame) -> pd.DataFrame:
df_join = duckdb.sql(
f"""
SELECT left_table.*, grouped_labels.labels FROM left_table
LEFT OUTER JOIN (
SELECT image_path, list(label) AS labels FROM sqlite_scan('{self.labelsdb_path}', 'labels') GROUP BY image_path
) AS grouped_labels
ON (left_table.image_path = grouped_labels.image_path)
ORDER BY left_table._distance ASC;
"""
).to_df()
df_join["labels"] = df_join["labels"].fillna("").apply(list)
return df_join
def create_zip_labeled_binary_data(self, output_dir: str, filename: str) -> str:
os.makedirs(output_dir, exist_ok=True)
lance_tbl = self.tbl.to_lance()
df = duckdb.sql(
f"""
SELECT lance_tbl.*, grouped_labels.labels FROM lance_tbl
INNER JOIN (
SELECT image_path, label AS labels FROM sqlite_scan('{self.labelsdb_path}', 'labels') WHERE (label='relevant' OR label='irrelevant')
) AS grouped_labels
ON (lance_tbl.image_path = grouped_labels.image_path);
"""
).to_df()
df.drop(columns=["vector"], inplace=True)
# Save df_hits to a CSV file in a temporary folder
with tempfile.TemporaryDirectory() as tmpdir:
csv_path = os.path.join(tmpdir, "data.csv")
df.to_csv(csv_path, index=False)
# Copy all image paths to the same temporary folder
for image_path in df["image_path"]:
src_path = os.path.join(self.data_path, image_path)
dst_path = os.path.join(tmpdir, image_path)
print("Copying", src_path, "to", dst_path)
os.makedirs(os.path.dirname(dst_path), exist_ok=True)
shutil.copy(src_path, dst_path)
# Create a zip file containing all files from the temporary folder
if output_dir is None:
output_dir = tempfile.gettempdir()
if filename.endswith(".zip"):
zip_path = os.path.join(output_dir, filename)
else:
zip_path = os.path.join(output_dir, filename + ".zip")
shutil.make_archive(zip_path[:-4], "zip", tmpdir)
return zip_path
| [
"lancedb.connect"
] | [((323, 383), 'duckdb.sql', 'duckdb.sql', (['"""\n INSTALL sqlite;\n LOAD sqlite;\n """'], {}), '("""\n INSTALL sqlite;\n LOAD sqlite;\n """)\n', (333, 383), False, 'import duckdb\n'), ((743, 777), 'os.path.join', 'os.path.join', (['db_path', '"""labels.db"""'], {}), "(db_path, 'labels.db')\n", (755, 777), False, 'import os\n'), ((1088, 1112), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (1103, 1112), False, 'import lancedb\n'), ((3438, 3478), 'os.path.join', 'os.path.join', (['self.data_path', 'image_path'], {}), '(self.data_path, image_path)\n', (3450, 3478), False, 'import os\n'), ((5927, 5965), 'os.makedirs', 'os.makedirs', (['output_dir'], {'exist_ok': '(True)'}), '(output_dir, exist_ok=True)\n', (5938, 5965), False, 'import os\n'), ((6543, 6572), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (6570, 6572), False, 'import tempfile\n'), ((6607, 6639), 'os.path.join', 'os.path.join', (['tmpdir', '"""data.csv"""'], {}), "(tmpdir, 'data.csv')\n", (6619, 6639), False, 'import os\n'), ((7474, 7523), 'shutil.make_archive', 'shutil.make_archive', (['zip_path[:-4]', '"""zip"""', 'tmpdir'], {}), "(zip_path[:-4], 'zip', tmpdir)\n", (7493, 7523), False, 'import shutil\n'), ((2056, 2127), 'duckdb.sql', 'duckdb.sql', (['f"""SELECT * FROM lance_tbl WHERE image_path=\'{image_path}\';"""'], {}), '(f"SELECT * FROM lance_tbl WHERE image_path=\'{image_path}\';")\n', (2066, 2127), False, 'import duckdb\n'), ((2723, 3125), 'duckdb.sql', 'duckdb.sql', (['f"""\n SELECT lance_tbl.*, grouped_labels.labels FROM lance_tbl\n LEFT OUTER JOIN (\n SELECT image_path, list(label) AS labels FROM sqlite_scan(\'{self.labelsdb_path}\', \'labels\') GROUP BY image_path\n ) AS grouped_labels\n ON (lance_tbl.image_path = grouped_labels.image_path)\n USING SAMPLE {limit} ROWS;\n """'], {}), '(\n f"""\n SELECT lance_tbl.*, grouped_labels.labels FROM lance_tbl\n LEFT OUTER JOIN (\n SELECT image_path, list(label) AS labels FROM sqlite_scan(\'{self.labelsdb_path}\', \'labels\') GROUP BY image_path\n ) AS grouped_labels\n ON (lance_tbl.image_path = grouped_labels.image_path)\n USING SAMPLE {limit} ROWS;\n """\n )\n', (2733, 3125), False, 'import duckdb\n'), ((5307, 5720), 'duckdb.sql', 'duckdb.sql', (['f"""\n SELECT left_table.*, grouped_labels.labels FROM left_table\n LEFT OUTER JOIN (\n SELECT image_path, list(label) AS labels FROM sqlite_scan(\'{self.labelsdb_path}\', \'labels\') GROUP BY image_path\n ) AS grouped_labels\n ON (left_table.image_path = grouped_labels.image_path)\n ORDER BY left_table._distance ASC;\n """'], {}), '(\n f"""\n SELECT left_table.*, grouped_labels.labels FROM left_table\n LEFT OUTER JOIN (\n SELECT image_path, list(label) AS labels FROM sqlite_scan(\'{self.labelsdb_path}\', \'labels\') GROUP BY image_path\n ) AS grouped_labels\n ON (left_table.image_path = grouped_labels.image_path)\n ORDER BY left_table._distance ASC;\n """\n )\n', (5317, 5720), False, 'import duckdb\n'), ((6019, 6399), 'duckdb.sql', 'duckdb.sql', (['f"""\n SELECT lance_tbl.*, grouped_labels.labels FROM lance_tbl\n INNER JOIN (\n SELECT image_path, label AS labels FROM sqlite_scan(\'{self.labelsdb_path}\', \'labels\') WHERE (label=\'relevant\' OR label=\'irrelevant\')\n ) AS grouped_labels\n ON (lance_tbl.image_path = grouped_labels.image_path);\n """'], {}), '(\n f"""\n SELECT lance_tbl.*, grouped_labels.labels FROM lance_tbl\n INNER JOIN (\n SELECT image_path, label AS labels FROM sqlite_scan(\'{self.labelsdb_path}\', \'labels\') WHERE (label=\'relevant\' OR label=\'irrelevant\')\n ) AS grouped_labels\n ON (lance_tbl.image_path = grouped_labels.image_path);\n """\n )\n', (6029, 6399), False, 'import duckdb\n'), ((6825, 6865), 'os.path.join', 'os.path.join', (['self.data_path', 'image_path'], {}), '(self.data_path, image_path)\n', (6837, 6865), False, 'import os\n'), ((6893, 6925), 'os.path.join', 'os.path.join', (['tmpdir', 'image_path'], {}), '(tmpdir, image_path)\n', (6905, 6925), False, 'import os\n'), ((7071, 7102), 'shutil.copy', 'shutil.copy', (['src_path', 'dst_path'], {}), '(src_path, dst_path)\n', (7082, 7102), False, 'import shutil\n'), ((7247, 7268), 'tempfile.gettempdir', 'tempfile.gettempdir', ([], {}), '()\n', (7266, 7268), False, 'import tempfile\n'), ((7338, 7372), 'os.path.join', 'os.path.join', (['output_dir', 'filename'], {}), '(output_dir, filename)\n', (7350, 7372), False, 'import os\n'), ((7418, 7461), 'os.path.join', 'os.path.join', (['output_dir', "(filename + '.zip')"], {}), "(output_dir, filename + '.zip')\n", (7430, 7461), False, 'import os\n'), ((7013, 7038), 'os.path.dirname', 'os.path.dirname', (['dst_path'], {}), '(dst_path)\n', (7028, 7038), False, 'import os\n')] |
import os
import datetime
import sys
import json
import time
import os
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import LanceDB
from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import CharacterTextSplitter
import lancedb
import openai
from flask import Flask, render_template, request, jsonify
from langchain.text_splitter import RecursiveCharacterTextSplitter
from werkzeug.utils import secure_filename
from deep_motion import DeepMotionHandler
from sketchfab import SketchfabHandler
os.environ["OPENAI_API_KEY"] = "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"
openai.api_key = "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"
loader = DirectoryLoader("static/langchain_documents/")
loaded_documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=100)
documents = text_splitter.split_documents(loaded_documents)
#documents = TextSplitter().split_documents(documents)
print(type(documents))
embeddings = OpenAIEmbeddings()
db = lancedb.connect("static/lanceDB")
table = db.open_table("my_table")
#
# table = db.create_table(
# "my_table",
# data=[
# {
# "vector": embeddings.embed_query("Hello World"),
# "text": "Hello World",
# "id": "1",
# }
# ],
# mode="overwrite",
#
# )
docsearch = LanceDB.from_documents(documents, embeddings, connection=table)
UPLOAD_FOLDER = '/uploaded_videos'
ALLOWED_EXTENSIONS = {'mp4', 'mov'}
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
current_convert_config = {"trainee_url": "", "coach_url": ""}
@app.route("/")
def home():
return render_template("home.html")
@app.route("/shottracer")
def shottracer():
print("here", flush=True)
return render_template("shottracer.html")
@app.route("/about")
def about():
return render_template("about.html")
@app.route("/upload", methods=["POST"])
def upload():
print("Entered upload", flush=True)
try:
uploaded_file = request.files['file']
if uploaded_file and uploaded_file.filename.endswith('.mp4'):
print("uploaded file and is mp4", flush=True)
uploaded_file.save('uploaded_video.mp4')
return {'message': 'Video uploaded and saved successfully'}
else:
print("failed lmao", flush=True)
return {'message': 'Invalid video file'}
except Exception as e:
return {'message': 'Error uploading video: ' + str(e)}
@app.route('/process', methods=['POST'])
def process():
print("in process", flush=True)
print(request.data, flush=True)
data = json.loads(request.data)
result = data['value']
current_convert_config["trainee_url"] = "static/videos/" + result
print("selected trainee: " + current_convert_config["trainee_url"], flush=True)
return jsonify(result=result)
@app.route('/coach_select', methods=["POST"])
def coach_select():
data = json.loads(request.data)
result = data['value']
current_convert_config["coach_url"] = "static/videos/" + result
print("selected coach: " + current_convert_config["coach_url"], flush=True)
return jsonify(result=result)
@app.route('/convert', methods=["POST"])
def convert():
print("converting", flush=True)
if current_convert_config["trainee_url"] == "" or current_convert_config["coach_url"] == "":
print(current_convert_config)
return current_convert_config
deep_motion = DeepMotionHandler()
trainee_resp, trainee_input = deep_motion.new_job(current_convert_config["trainee_url"], download=False)
coach_resp, coach_input = deep_motion.new_job(current_convert_config["coach_url"], download=False)
trainee_fbx = deep_motion.download_job(trainee_resp, trainee_input)
coach_fbx = deep_motion.download_job(coach_resp, coach_input)
print(trainee_fbx, flush=True)
print(coach_fbx, flush=True)
sketchfab_handler = SketchfabHandler()
trainee_url = sketchfab_handler.upload(trainee_fbx)
coach_url = sketchfab_handler.upload(coach_fbx)
print(trainee_url, flush=True)
print(coach_url, flush=True)
while not sketchfab_handler.poll_processing_status(trainee_url) or not sketchfab_handler.poll_processing_status(coach_url):
time.sleep(1)
return jsonify('{"trainee": "' + trainee_url.rsplit('/', 1)[-1] + '", "coach": "' + coach_url.rsplit('/', 1)[-1] + '"}')
#return jsonify('{"trainee": "791e22a2678e4e05b56df1107dd1f8e8", "coach": "af8a9327edf3432f981000210da42022"}')
#return (trainee_url.rsplit('/', 1)[-1], coach_url.rsplit('/', 1)[-1])
@app.route("/search", methods=["POST"])
def docSearch():
print("in search", flush=True)
print(request.data, flush=True)
data = json.loads(request.data)
question = data['question']
docs = docsearch.similarity_search(question)
prompt = f"""Given the question: {question} and this context: {docs}
Answer the question as best as possible. Use any relevant information from the context to
enrich your answer.
Final Answer:
"""
response = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
max_tokens=300
)
generated_text = response.choices[0].text
return jsonify(result=generated_text)
if __name__ == "__main__":
app.run(host="127.0.0.1", port=8080, debug=True) | [
"lancedb.connect"
] | [((730, 776), 'langchain.document_loaders.DirectoryLoader', 'DirectoryLoader', (['"""static/langchain_documents/"""'], {}), "('static/langchain_documents/')\n", (745, 776), False, 'from langchain.document_loaders import DirectoryLoader\n'), ((827, 883), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(300)', 'chunk_overlap': '(100)'}), '(chunk_size=300, chunk_overlap=100)\n', (848, 883), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((1035, 1053), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (1051, 1053), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((1060, 1093), 'lancedb.connect', 'lancedb.connect', (['"""static/lanceDB"""'], {}), "('static/lanceDB')\n", (1075, 1093), False, 'import lancedb\n'), ((1389, 1452), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['documents', 'embeddings'], {'connection': 'table'}), '(documents, embeddings, connection=table)\n', (1411, 1452), False, 'from langchain.vectorstores import LanceDB\n'), ((1532, 1547), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (1537, 1547), False, 'from flask import Flask, render_template, request, jsonify\n'), ((1695, 1723), 'flask.render_template', 'render_template', (['"""home.html"""'], {}), "('home.html')\n", (1710, 1723), False, 'from flask import Flask, render_template, request, jsonify\n'), ((1810, 1844), 'flask.render_template', 'render_template', (['"""shottracer.html"""'], {}), "('shottracer.html')\n", (1825, 1844), False, 'from flask import Flask, render_template, request, jsonify\n'), ((1891, 1920), 'flask.render_template', 'render_template', (['"""about.html"""'], {}), "('about.html')\n", (1906, 1920), False, 'from flask import Flask, render_template, request, jsonify\n'), ((2666, 2690), 'json.loads', 'json.loads', (['request.data'], {}), '(request.data)\n', (2676, 2690), False, 'import json\n'), ((2892, 2914), 'flask.jsonify', 'jsonify', ([], {'result': 'result'}), '(result=result)\n', (2899, 2914), False, 'from flask import Flask, render_template, request, jsonify\n'), ((2994, 3018), 'json.loads', 'json.loads', (['request.data'], {}), '(request.data)\n', (3004, 3018), False, 'import json\n'), ((3208, 3230), 'flask.jsonify', 'jsonify', ([], {'result': 'result'}), '(result=result)\n', (3215, 3230), False, 'from flask import Flask, render_template, request, jsonify\n'), ((3516, 3535), 'deep_motion.DeepMotionHandler', 'DeepMotionHandler', ([], {}), '()\n', (3533, 3535), False, 'from deep_motion import DeepMotionHandler\n'), ((3982, 4000), 'sketchfab.SketchfabHandler', 'SketchfabHandler', ([], {}), '()\n', (3998, 4000), False, 'from sketchfab import SketchfabHandler\n'), ((4787, 4811), 'json.loads', 'json.loads', (['request.data'], {}), '(request.data)\n', (4797, 4811), False, 'import json\n'), ((5127, 5213), 'openai.Completion.create', 'openai.Completion.create', ([], {'engine': '"""text-davinci-003"""', 'prompt': 'prompt', 'max_tokens': '(300)'}), "(engine='text-davinci-003', prompt=prompt,\n max_tokens=300)\n", (5151, 5213), False, 'import openai\n'), ((5299, 5329), 'flask.jsonify', 'jsonify', ([], {'result': 'generated_text'}), '(result=generated_text)\n', (5306, 5329), False, 'from flask import Flask, render_template, request, jsonify\n'), ((4315, 4328), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (4325, 4328), False, 'import time\n')] |
from PIL import Image
import streamlit as st
import openai
#exercise 11
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
#exercise 12
from langchain.memory import ConversationBufferWindowMemory
#exercise 13
from langchain.document_loaders import TextLoader,PyPDFLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import LanceDB
import lancedb
import os
import tempfile
#exercise 15
import sqlite3
import pandas as pd
from datetime import datetime
#exercise 16
from langchain.agents import ConversationalChatAgent, AgentExecutor
from langchain.callbacks import StreamlitCallbackHandler
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.memory.chat_message_histories import StreamlitChatMessageHistory
from langchain.tools import DuckDuckGoSearchRun
#Exercise 17
from langchain.agents import tool
import json
#Exercise 18
from pandasai import SmartDataframe
from pandasai.llm.openai import OpenAI
import matplotlib.pyplot as plt
os.environ["OPENAI_API_KEY"] = st.secrets["openapi_key"]
openai.api_key = st.secrets["openapi_key"]
#Global ex 13
cwd = os.getcwd()
WORKING_DIRECTORY = os.path.join(cwd, "database")
if not os.path.exists(WORKING_DIRECTORY):
os.makedirs(WORKING_DIRECTORY)
#ex15
DB_NAME = os.path.join(WORKING_DIRECTORY, "default_db")
def template():
st.subheader("Template")
st.write("Instruction lines.")
st.markdown("**:blue[Code]**")
st.code('''
#exercise code here
''')
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
#challenge code here
''')
st.markdown("**:red[Code Output]**")
# Actual code here
def class1_prep():
# st.subheader("Course Slides")
# st.markdown("https://go.gov.sg/itdchatbotprototype")
st.divider()
st.subheader("Pre-workshop Setup")
# st.divider()
st.markdown("""1. Visual Studio (VS Code): this is the Integrated Development Environment (IDE) of choice by many coders and will make it easier for us to code our app.""")
st.markdown("""2. Python (3.10 release or later): this is the coding language of choice for many data science related apps.""")
st.write("""
3. Once you have installed the above, we will need to set up a virtual environment and install the libraries in that environment.\n
Create a folder named “chatbot” anywhere, e.g. in your Desktop.\n
Open VS Code and navigate to the folder in a new terminal window.\n
Create a virtual environment and activate it by entering the following commands in the terminal:
""")
st.markdown(" **a) Mac**")
st.code('''
python3 -m venv venv
source venv/bin/activate
''')
st.markdown("(You should see a (venv) appear in your terminal window prompt)")
st.markdown("#")
st.markdown(" **b) Windows**")
st.code('''
python -m venv venv
cd venv\Scripts
activate
''')
st.markdown("4. While in your virtual environment, install the libraries using pip which should already be installed together with Python:")
st.code('''
pip install streamlit openai
''')
st.markdown(" To test if Streamlit is installed properly, run this command:")
st.code('''
streamlit hello
''')
st.markdown(" You should see a Streamlit application running at http://localhost:8501")
st.markdown(" Type Ctrl + C in VS Code terminal to stop the Streamlit app")
pass
def class1_hw1():
st.subheader("My first Hello World app")
st.divider()
st.markdown("""1. Create a new file called 'main.py'.""")
st.markdown("""2. Copy the code below and paste it in the newly created helloworld.py file.""")
st.markdown("**:blue[Code]**")
st.code('''
import streamlit as st
#my first Hello World app
st.write("Hello World")
''')
st.markdown("Install the watchdog module by running the command below in the terminal.")
st.code("pip install watchdog")
st.markdown("Now you don't have to keep restarting the app to see the changes you make to the code. Just refresh the browser.")
st.write("Save your file and run the app by typing the following command in the terminal:")
st.code('''
streamlit run main.py
''')
st.markdown("""3. You should see a Streamlit application running at http://localhost:8501""")
st.markdown("""4. Type Ctrl + C in VS Code terminal to stop the Streamlit app""")
st.markdown("**:red[Code Output]**")
st.write("Hello World")
pass
def objectives():
st.subheader("Objectives")
st.markdown("1. Learn how to use Python and Streamlit library to create an interactive web app.")
st.markdown("2. Learn how to integrate and use OpenAI's API in their streamlit application to create a simple chatbot.")
st.markdown("3. Learn how to apply basic prompt engineering to enhance the interaction with the chatbot.")
def workshop_outline():
st.subheader("Outline")
st.markdown("Part 0: Workshop introduction and rules")
st.markdown("Part 1: Introduction to Python and Streamlit")
st.markdown("Part 2: Creating a rule-based chatbot")
st.markdown("Part 3: Creating a chatbot using OpenAI's API")
st.markdown("Part 4: Modifying your chatbot with prompt engineering")
def team_introduction():
st.write("Do introduce yourself to your teammates:\n", "1) name\n", "2) division\n", "3) role")
st.write("Please also share your favourite Star Wars character and why!")
image = Image.open('team_introductions.jpeg')
st.image(image, caption='Hello there!')
def workshop_rules():
st.subheader("Workshop Rules")
st.write("1. Ask if you have questions.")
st.write("2. Be open to different ways to solve the problem.")
st.write("3. Try. Fail. Learn. Repeat.")
st.write("4. Seek help from other team members.")
st.write("5. Collaborate, if possible, for the challenges.")
st.write("6. Approach facilitators if your team cannot solve the problem.")
st.write("7. Toilet break is own-time-own-target.")
st.write("8. Have fun!")
def vscode_ui():
st.subheader("Navigating the VS Code interface")
image = Image.open('VSCode_interface.png')
st.image(image, caption='VS Code UI layout')
st.markdown("**A: Activity Bar: this is where you can see the different activities you can do in VS Code.**")
st.markdown(" Explorer: this is where you can see all the files and folders in your project.")
st.markdown(" Source Control: this is where you can see the changes you have made to your project.")
st.markdown(" Extensions: this is where you can install extensions to VS Code.")
st.markdown(" Run and Debug: this is where you can debug your code.")
st.markdown("**B: Side Bar: this is where you can see the different views of your project.**")
st.markdown("**C: Editor: this is where you can see the code you have written in your project.**")
st.markdown("**D: Panel: this is where you can see the different panels you have opened in your project.**")
st.markdown(" Terminal: this is where you can run commands in your project.")
st.markdown(" Output: this is where you can see the output of your code.")
st.markdown(" Problems: this is where you can see the errors in your code.")
st.markdown("**E. Status Bar: this is where you can see the status of your project.**")
def command_palette_indent():
st.markdown("Python is very particular about indentation.\nUse the command palette to automatically indent your code.\n\nWindows: Ctrl-Shift-P \nMac: Command-Shift-P\n\nSelect the option to *Convert Indentation to Tabs*")
image = Image.open('command_palette_command.png')
st.image(image, caption='Command Palette auto-indent command')
def final_product():
st.write("This is what we will working towards and building by the end of the workshop today.")
st.write("Do try out the chatbot below!")
st.subheader("**:green[Feel the force! Yoda Chatbot]**")
image = Image.open('yoda.jpg')
st.image(image, caption='Master Yoda at your service')
st.divider()
openai.api_key = st.secrets["openapi_key"]
prompt_template = """
"Speak like Yoda from Star Wars for every question that was asked,
do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"
"""
if "openai_model" not in st.session_state:
st.session_state["openai_model"] = "gpt-3.5-turbo"
if "msg_bot" not in st.session_state:
st.session_state.msg_bot = []
for message in st.session_state.msg_bot:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
if prompt := st.chat_input("What is up?"):
st.session_state.msg_bot.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
for response in openai.ChatCompletion.create(
model=st.session_state["openai_model"],
messages=[
{"role": "system", "content": prompt_template},
{"role": "user", "content": prompt},
],
stream=True,
):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg_bot.append({"role": "assistant", "content": full_response})
except Exception as e:
st.error(e)
pass
def resources():
st.subheader("Useful resources and references")
st.markdown("1. [Streamlit documentation](https://docs.streamlit.io/en/stable/)")
st.markdown("2. [OpenAI API documentation](https://beta.openai.com/docs/introduction)")
st.markdown("3. [VS Code documentation](https://code.visualstudio.com/docs)")
st.markdown("4. [Python documentation](https://docs.python.org/3/)")
st.markdown("5. [Python cheatsheet](https://www.pythoncheatsheet.org/)")
st.markdown("6. [Python for beginners](https://www.python.org/about/gettingstarted/)")
st.markdown("7. [ChatGPT](https://chat.openai.com/) - you can ask ChatGPT to generate code for you!")
st.markdown("**Notes for this workshop course:** \n- you may do a single click to copy all the code \n- challenge code is hidden, click reveal to see the code")
st.markdown("Python is very particular about indentation.\nUse the command palette to automatically indent your code.\n\nWindows: Ctrl-Shift-P \nMac: Command-Shift-P\n\nSelect the option to *Convert Indentation to Tabs*")
image = Image.open('command_palette_command.png')
st.image(image, caption='Command Palette auto-indent command')
def part1_intro1():
st.subheader("Streamlit")
st.markdown("""
* an open-source Python library
* used extensively for machine learning and data science
* helps to create interactive web apps in just a few lines of code
* highly flexible and supports complex interactive apps with highly customisable UI
* Some real world examples:
* CherGPT in String
* Metacog for CotF MOE
* AILC prototype for MOE
""")
def ex1():
# Exercise 1 : Functions
st.write("Hello World")
# only prints the Hello {name} if input box is not empty
name = st.text_input("Enter your name")
if name:
st.write("Hello " + name)
def class1_ex1():
st.subheader("Exercise 1: Functions")
st.markdown("In the ***main.py*** file, the code below is already in ***ex1()*** in the ***part1.py*** file.")
st.write("The code for *helloworld* is inside what you call a Python function.")
st.write("The ***def main()*** function and ***if _ _ name _ _ == '_ _ main _ _'*** statement are coding conventions for any Python programme.")
st.write("You need to include an import statement in ***main.py*** to import the ***ex1()*** function from the other file.")
st.code('''
from part1 import ex1
''')
st.write("You will need to do the same for all the other exercises and challenges for the rest of the workshop. The code exercises are already in the respective files: ***part1.py, part2.py, part3.py, part4.py***.")
st.markdown("**:blue[Code]**")
st.code('''
import streamlit as st
from part1 import ex1
#Exercise 1: Functions
def ex1():
st.write("Hello World")
name = st.text_input("Enter your name")
if name:
st.write("Hello " + name)
def main():
ex1()
if __name__ == "__main__":
main()
''')
st.markdown("Run the code by typing the following into the terminal:")
st.code("streamlit run main.py")
st.markdown("You should see the following behaviour in your browser window:")
st.markdown("**:red[Code Output]**")
#actual code here
ex1()
def ch1():
name = st.text_input("Enter your name")
gender = st.selectbox("State your gender", ["Male", "Female"])
age = st.text_input("State your age", 18)
if name and gender and age:
st.text(f"Hello {name}, you are {gender} and this year you are {age} years old")
def class1_ch1():
st.subheader("Challenge 1: Input, Output and Variables")
st.write("Create a new function called ***ch1()*** in ***part1.py*** and call it in the main function.")
st.write("Create three variables *name*, *age* and *gender*, and obtain these from the user.")
st.write("Once the user filled up the input boxes, display back the information to the user.")
st.write("Code hint: the following piece of code checks if *name* has been filled, and if so, displays it back to the user.")
st.code('''
name = st.text_input("Enter your name")
if name:
st.text(f"Hello {name}")
''')
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
def ch1():
name = st.text_input("Enter your name")
gender = st.selectbox("State your gender", ["Male", "Female"])
age = st.text_input("State your age", 18)
if name and gender and age:
st.text(f"Hello {name}, you are {gender} and this year you are {age} years old")
''')
st.markdown("**:red[Code Output]**")
# Actual code here
ch1()
def ex2():
gender = st.selectbox("State your gender", ["Male", "Female"])
age = int(st.text_input("State your age", 18))
photo = st.camera_input("Smile! take a picture here.")
# conditional logic to run different statements
if age >= 21 and gender == "Male":
st.write("You are a male adult")
elif age < 21 and gender == "Male":
st.write("You are a young boy")
elif age >= 21 and gender == "Female":
st.write("You are a female adult")
elif age < 21 and gender == "Female":
st.write("You are a young girl")
if photo:
st.write("Here is your photo: ")
st.image(photo)
else:
st.write("No photo taken")
def class1_ex2():
st.subheader("Exercise 2: If-else logical conditionals")
st.markdown("If-else statements help control the flow and logic of our application.")
st.markdown("**:blue[Code]**")
st.code('''
def ex2():
gender = st.selectbox("State your gender", ["Male", "Female"])
age = int(st.text_input("State your age", 18))
photo = st.camera_input("Smile! take a picture here.")
# conditional logic to run different statements
if age >= 21 and gender == "Male":
st.write("You are a male adult")
elif age < 21 and gender == "Male":
st.write("You are a young boy")
elif age >= 21 and gender == "Female":
st.write("You are a female adult")
elif age < 21 and gender == "Female":
st.write("You are a young girl")
if photo:
st.write("Here is your photo: ")
st.image(photo)
else:
st.write("No photo taken")
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex2()
def ex3():
# Data list
fruits = ["apple", "banana", "orange"]
# For loop to show list
for fruit in fruits:
st.write(fruit)
# Dictionary
person = {"name": "John", "age": 30, "gender": "Male", "city": "New York"}
# Print out the items in the dictionary
st.write("Here is your *person* dictionary: ")
st.write(person)
# for loop to show dictionary list
st.write("You can also show individual items in the dictionary like this: ")
for key, value in person.items():
st.write(key + ": " + str(value))
# get user input to update the dictionary
name = st.text_input("Enter your name", "John")
age = st.text_input("State your age", 30)
gender = st.selectbox("State your gender", ["Male", "Female"])
city = st.text_input("State your city", "New York")
person["name"] = name
person["age"] = age
person["gender"] = gender
person["city"] = city
st.write("Here is your updated *person* dictionary: ")
st.write(person)
def class1_ex3():
st.subheader("Exercise 3: Data and Loops ")
st.write("We can store data in a list or dictionary and display the data using a for loop.")
st.write("Append the following code to the ***main.py*** file. Refresh the browser to see the changes.")
st.write("You should see output similar to the *Code Output* below.")
st.markdown("**:blue[Code]**")
st.code('''
#Data and Loops
def ex3():
# Data list
fruits = ["apple", "banana", "orange"]
# For loop to show list
for fruit in fruits:
st.write(fruit)
# Dictionary
person = {"name": "John", "age": 30, "city": "New York"}
# Print out the items in the dictionary
st.write("Here is your *person* dictionary: ")
st.write(person)
# for loop to show dictionary list
st.write("You can also show individual items in the dictionary like this: ")
for key, value in person.items():
st.write(key + ": " + str(value))
# get user input to update the dictionary
name = st.text_input("Enter your name", "John")
age = st.text_input("State your age", 30)
gender = st.selectbox("State your gender", ["Male", "Female"])
city = st.text_input("State your city", "New York")
person["name"] = name
person["age"] = age
person["gender"] = gender
person["city"] = city
st.write("Here is your updated *person* dictionary: ")
st.write(person)
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex3()
def ex4a():
#Exercise 4a: Creating Session Data
if "session_data" not in st.session_state:
st.session_state.session_data = ["alpha", "omega"]
if "name" not in st.session_state:
st.session_state.name = ""
if "age" not in st.session_state:
st.session_state.age = ""
if "gender" not in st.session_state:
st.session_state.gender = ""
# For loop to show list
for data in st.session_state.session_data:
st.write("session_data: ", data)
st.write("name: ", st.session_state.name)
st.write("age: ", st.session_state.age)
st.write("gender: ", st.session_state.gender)
def class1_ex4a():
st.subheader("Exercise 4a: Session Data")
st.write("We can create variables to store data in a user session. Session data persist within a user session.")
st.markdown("**:blue[Code]**")
st.code('''
# Exercise 4: Session State
def ex4a():
st.subheader("Session Data:")
if "session_data" not in st.session_state:
st.session_state.session_data = ["alpha", "omega"]
if "name" not in st.session_state:
st.session_state.name = ""
if "age" not in st.session_state:
st.session_state.age = ""
if "gender" not in st.session_state:
st.session_state.gender = ""
# For loop to show list
for data in st.session_state.session_data:
st.write("session_data: ", data)
st.write("name: ", st.session_state.name)
st.write("age: ", st.session_state.age)
st.write("gender: ", st.session_state.gender)
''')
st.markdown("**:red[Code Output]**")
ex4a()
def ex4b():
#Exercise 4b: Session Data with User Input
user_name = st.text_input("Enter your name")
user_age = st.text_input("State your age")
user_gender = st.selectbox("State your gender", ["", "Male", "Female"])
if user_name:
st.session_state.name = user_name
st.write("name: ", st.session_state.name)
if user_age:
st.session_state.age = int(user_age)
st.write("age: ", st.session_state.age)
if user_gender:
st.session_state.gender = user_gender
st.write("gender: ", st.session_state.gender)
def class1_ex4b():
st.subheader("Exercise 4b: Session Data with User Input")
st.write("Lets now get input from the user and store it in the session data.")
st.write("Now run *ex4a()* again to check the session data. Note that it persists.")
st.markdown("**:blue[Code]**")
st.code('''
def ex4b():
st.subheader("Session Data:")
userName = st.text_input("Enter your name")
userAge = st.text_input("State your age")
userGender = st.selectbox("State your gender", ["", "Male", "Female"])
if userName:
st.session_state.name = userName
st.write("name: ", st.session_state.name)
if userAge:
st.session_state.age = int(userAge)
st.write("age: ", st.session_state.age)
if userGender:
st.session_state.gender = userGender
st.write("gender: ", st.session_state.gender)
''')
st.markdown("**:red[Code Output]**")
ex4b()
def ch4():
if "name" not in st.session_state:
st.session_state.name = "Yoda"
if "age" not in st.session_state:
st.session_state.age = 999
if "gender" not in st.session_state:
st.session_state.gender = "male"
if "prompt_template" not in st.session_state:
st.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"
st.write("session_state.name: ", st.session_state.name)
st.write("session_state.age: ", st.session_state.age)
st.write("session_state.gender: ", st.session_state.gender)
st.write("session_state.prompt_template: ", st.session_state.prompt_template)
def class1_ch4():
st.subheader("Challenge 4: Session Data")
st.markdown("""
Add a new function called ***ch4()*** to the ***part1.py*** file and call it in the main function.\n
In *ch4()*, modify the code in Exercise 4b to include the following:
* Create session data for ***name***, ***age*** and ***gender***
* Create session data for ***prompt_template*** with the following value:
"Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"
* Include this code in ***main()*** as well, because we need the session data for later exercises. Omit the ***st.write*** functions, since we do not want to see this output every time we run ***main()***. \n
Hint:
* In ***ch4()***, to check that the session data is created, you can print out the session data using ***st.write()***:
""")
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
def ch4():
if "name" not in st.session_state:
st.session_state.name = "Yoda"
if "age" not in st.session_state:
st.session_state.age = 999
if "gender" not in st.session_state:
st.session_state.gender = "male"
if "prompt_template" not in st.session_state:
st.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"
st.write("session_state.name: ", st.session_state.name)
st.write("session_state.age: ", st.session_state.age)
st.write("session_state.gender: ", st.session_state.gender)
st.write("session_state.prompt_template: ", st.session_state.prompt_template)
def main():
# initialize session state, from ch4
if "name" not in st.session_state:
st.session_state.name = "Yoda"
if "age" not in st.session_state:
st.session_state.age = 999
if "gender" not in st.session_state:
st.session_state.gender = "male"
if "prompt_template" not in st.session_state:
st.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"
#the rest of your code is below
''')
st.markdown("**:red[Code Output]**")
#actual code here
ch4()
def ex5():
st.title("My first chatbot")
if "store_msg" not in st.session_state:
st.session_state.store_msg = []
prompt = st.chat_input("Say something")
if prompt:
st.write(f"User has sent the following prompt: {prompt}")
st.session_state.store_msg.append(prompt)
for message in st.session_state.store_msg:
with st.chat_message("user"):
st.write(message)
with st.chat_message("assistant"):
st.write("Hello human, what can I do for you?")
def class1_ex5():
st.subheader("Exercise 5: Elements of a chatbot")
st.write("We will start creating a user interface for our first chatbot.")
st.write("Call the following code from ***part1.py*** in your **main()**.")
st.write("You should see the output below when you run your programme.")
st.markdown("**:blue[Code]**")
st.code('''
#Exercise 5 : Chatbot UI
def ex5():
st.title("My first chatbot")
if "store_msg" not in st.session_state:
st.session_state.store_msg = []
prompt = st.chat_input("Say something")
if prompt:
st.write(f"User has sent the following prompt: {prompt}")
st.session_state.store_msg.append(prompt)
for message in st.session_state.store_msg:
with st.chat_message("user"):
st.write(message)
with st.chat_message("assistant"):
st.write("Hello human, what can I do for you?")
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex5()
def ex6():
st.markdown("**Echo Bot**")
# Initialize chat history
if "messages" not in st.session_state:
st.session_state.messages = []
# Display chat messages from history on app rerun
for message in st.session_state.messages:
with st.chat_message(message["role"]):
st.markdown(message["content"])
# React to user input
if prompt := st.chat_input("What is up?"):
# Display user message in chat message container
st.chat_message("user").markdown(prompt)
# Add user message to chat history
st.session_state.messages.append({"role": "user", "content": prompt})
response = f"Echo: {prompt}"
# Display assistant response in chat message container
with st.chat_message("assistant"):
st.markdown(response)
# Add assistant response to chat history
st.session_state.messages.append({"role": "assistant", "content": response})
def class1_ex6():
st.subheader("Exercise 6: Building a simple echo chatbot")
st.write("We will now build a simple echo chatbot.")
st.write("Call the following code from **part1.py** in your ***main()***.")
st.write("You should see the output below when you run your programme.")
st.markdown("**:blue[Code]**")
st.code('''
#Exercise 6 : Rule-based Echo Chatbot
def ex6():
st.title("Echo Bot")
# Initialize chat history
if "messages" not in st.session_state:
st.session_state.messages = []
# Display chat messages from history on app rerun
for message in st.session_state.messages:
with st.chat_message(message["role"]):
st.markdown(message["content"])
# React to user input
if prompt := st.chat_input("What is up?"):
# Display user message in chat message container
st.chat_message("user").markdown(prompt)
# Add user message to chat history
st.session_state.messages.append({"role": "user", "content": prompt})
response = f"Echo: {prompt}"
# Display assistant response in chat message container
with st.chat_message("assistant"):
st.markdown(response)
# Add assistant response to chat history
st.session_state.messages.append({"role": "assistant", "content": response})
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex6()
def ch6():
st.markdown("**Rule Based Bot**")
# Initialize chat history
if "messages" not in st.session_state:
st.session_state.messages = []
# # Display chat messages from history on app rerun
for message in st.session_state.messages:
with st.chat_message(message["role"]):
st.markdown(message["content"])
# React to user input
if prompt := st.chat_input("Enter your query"):
if prompt == "Hello":
reply = "Hi there what can I do for you"
elif prompt == "What is your name?":
reply = "My name is EAI , an electronic artificial being"
elif prompt == "How old are you?":
reply = "Today is my birthday!"
else:
reply = "I am sorry, I am unable to help you with your query"
with st.chat_message("user"):
st.write(prompt)
st.session_state.messages.append({"role": "user", "content": prompt})
with st.chat_message("assistant"):
st.write(reply)
st.session_state.messages.append({"role": "assistant", "content": reply})
def class1_ch6():
st.subheader("Challenge 6: Rule based chatbot ")
st.markdown("""
Create a new function called ***ch6()*** in **part1.py** and modify the ***ex6()*** function to create the following rule based chatbot:\n
* Human : “Hello”, Assistant: “Hi there what can I do for you”\n
* Human : “What is your name?”, Assistant: “My name is EAI , an electronic artificial being”\n
* Human : “How old are you?”, Assistant: “Today is my birthday!”\n
For other queries, it will reply “I am sorry, I am unable to help you with your query”\n
Use *if / elif / else* statements to create the chatbot behaviour logic.\n
You should see the output below when you run your programme.\n
""")
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
#Challenge 6 : Rule-based If-Else Chatbot
def ch6():
st.markdown("**Rule Based Bot**")
# Initialize chat history
if "messages" not in st.session_state:
st.session_state.messages = []
# # Display chat messages from history on app rerun
for message in st.session_state.messages:
with st.chat_message(message["role"]):
st.markdown(message["content"])
# React to user input
if prompt := st.chat_input("Enter your query"):
if prompt == "Hello":
reply = "Hi there what can I do for you"
elif prompt == "What is your name?":
reply = "My name is EAI , an electronic artificial being"
elif prompt == "How old are you?":
reply = "Today is my birthday!"
else:
reply = "I am sorry, I am unable to help you with your query"
with st.chat_message("user"):
st.write(prompt)
st.session_state.messages.append({"role": "user", "content": prompt})
with st.chat_message("assistant"):
st.write(reply)
st.session_state.messages.append({"role": "assistant", "content": reply})
''')
st.markdown("**:red[Code Output]**")
#actual code here
ch6()
def class1_ex7():
st.subheader("Exercise 7: Secrets- Shhh ")
st.write("In this exercise, we will learn how to hide your API key")
st.markdown("""
In your working directory (chatbot), create a directory called **.streamlit**\n
Note the *dot* in front of the directory\n
In this folder, create a file called **secrets.toml**\n
Get an API key from your OpenAI account and type the following in **secrets.toml**:
""")
st.markdown("**:blue[Code]**")
st.code('''
openapi_key = "xxxxxx"
''')
st.write("Include the following global variables in your ***main.py*** file under the import statements:")
st.code('''
os.environ["OPENAI_API_KEY"] = st.secrets["openapi_key"]
openai.api_key = st.secrets["openapi_key"]
''')
st.write("Create a .gitignore file and add .streamlit into it")
#st.markdown("**:red[Code Output]**")
pass
def class1_ch7():
pass
def ex8():
st.title("Api Call")
MODEL = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Tell me about Singapore in the 1970s in 50 words."},
],
temperature=0,
)
st.markdown("**This is the raw response:**")
st.write(response)
st.markdown("**This is the extracted response:**")
st.write(response["choices"][0]["message"]["content"].strip())
s = str(response["usage"]["total_tokens"])
st.markdown("**Total tokens used:**")
st.write(s)
def class1_ex8():
st.subheader("Exercise 8: Calling the OpenAI LLM API")
st.write("In this exercise, we will learn how to call the OpenAI LLM API")
st.write("Note that there is a new import statement **import openai**")
st.markdown("""
Call the following code in your **main()** and run it.\n
You should see the output as shown below.\n
""")
st.markdown("**:blue[Code]**")
st.code('''
import openai
#Exercise 8 : Using the OpenAI API
def ex8():
st.title("Api Call")
MODEL = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Tell me about Singapore in the 1970s in 50 words."},
],
temperature=0,
)
st.markdown("**This is the raw response:**")
st.write(response)
st.markdown("**This is the extracted response:**")
st.write(response["choices"][0]["message"]["content"].strip())
s = str(response["usage"]["total_tokens"])
st.markdown("**Total tokens used:**")
st.write(s)
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex8()
def chat_completion(prompt):
MODEL = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": prompt},
],
temperature=0,
)
return response["choices"][0]["message"]["content"].strip()
def class1_ch8():
st.subheader("Challenge 8: Incorporate your LLM API call into your chatbot")
st.write("In this challenge, we will incorporate the LLM API call into our previous rule-based *Echo* chatbot")
st.markdown("""
**Step1**\n
Create a new function **ch8()** in ***part1.py*** and copy the code from **ex6()** into it. Recall that **ex6()** shows the chat history and gets a chat input from the user, and echoes the user input back to the user. \n
**Step 2**\n
Next, copy the code from **ex8** into a new function named **chat_completion()**. Recall that **ex8()** is about making an API call.\n
Now, instead of echoing the user's input in **ex6()**, we will call the LLM API to generate a response. In particular, we are replacing this line of code with the response from the API call:\n
""")
st.code('''
response = f"Echo: {prompt}"
''')
st.markdown("""
**Step 3**\n
In **chat_completion()**, what we will do is to replace the previous *Tell me the history ..."* prompt from **ex8()** with the current user's input.\n
In order to do so, in **ch8()**, use the following code to call **chat_completion()**.\n
What we are doing now is to pass the prompt from the user to the API call instead of hard-coding the prompt as in **ex8()**.\n""")
st.code('''
if prompt := st.chat.input("What's up?"):
#display user messgae in chat message container
reply = chat_completion(prompt)
st.chat_message("user").markdown(prompt)
''')
st.write("You should see the code output as shown below.")
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
#Challenge 8: Incorporating the API into your chatbot
def chat_completion(prompt):
MODEL = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": prompt},
],
temperature=0,
)
return response["choices"][0]["message"]["content"].strip()
def ch8():
st.title("My first LLM Chatbot")
# Initialize chat history
if "chat_msg" not in st.session_state:
st.session_state.chat_msg = []
# Display chat chat_msg from history on app rerun
for message in st.session_state.chat_msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
# React to user input
if prompt := st.chat_input("What's up?"):
# Display user message in chat message container
reply = chat_completion(prompt)
st.chat_message("user").markdown(prompt)
# Add user message to chat history
st.session_state.chat_msg.append({"role": "user", "content": prompt})
# Display assistant response in chat message container
with st.chat_message("assistant"):
st.markdown(reply)
# Add assistant response to chat history
st.session_state.chat_msg.append({"role": "assistant", "content": reply})
''')
st.markdown("**:red[Code Output]**")
st.title("My LLM Chatbot")
# Initialize chat history
if "chat_msg" not in st.session_state:
st.session_state.chat_msg = []
# Display chat chat_msg from history on app rerun
for message in st.session_state.chat_msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
# React to user input
if prompt := st.chat_input("What is up?"):
# Display user message in chat message container
reply = chat_completion(prompt)
st.chat_message("user").markdown(prompt)
# Add user message to chat history
st.session_state.chat_msg.append({"role": "user", "content": prompt})
# Display assistant response in chat message container
with st.chat_message("assistant"):
st.markdown(reply)
# Add assistant response to chat history
st.session_state.chat_msg.append({"role": "assistant", "content": reply})
def chat_completion_stream(prompt):
MODEL = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": prompt},
],
temperature=0, # temperature
stream=True, # stream option
)
return response
def ex9_basebot():
# Initialize chat history
if "chat_msg" not in st.session_state:
st.session_state.chat_msg = []
# Showing Chat history
for message in st.session_state.chat_msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# set user prompt in chat history
st.session_state.chat_msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.chat_msg.append(
{"role": "assistant", "content": full_response}
)
except Exception as e:
st.error(e)
def class1_ex9():
st.subheader("Exercise 9: Building a ChatGPT-like clone with streaming responses")
st.write("Now, we will incorporate a streaming response from the LLM API into our chatbot to mimic the behaviour of ChatGPT.")
st.write("Copy and run the code below to see the streaming responses.")
st.markdown("**:blue[Code]**")
st.code('''
# Exercise 9 : Using the OpenAI API with streaming option
def chat_completion_stream(prompt):
openai.api_key = st.secrets["openapi_key"]
MODEL = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": prompt},
],
temperature=0, # temperature
stream=True, # stream option
)
return response
# integration API call into streamlit chat components
def ex9_basebot():
# Initialize chat history
if "chat_msg" not in st.session_state:
st.session_state.chat_msg = []
# Showing Chat history
for message in st.session_state.chat_msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# set user prompt in chat history
st.session_state.chat_msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.chat_msg.append(
{"role": "assistant", "content": full_response}
)
except Exception as e:
st.error(e)
''')
st.markdown("**:red[Code Output]**")
ex9_basebot()
def class1_ch9():
pass
def ex10():
# prompt_template in session state already set in main()
MODEL = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": st.session_state.prompt_template},
{
"role": "user",
"content": "Tell me about Singapore in the 1970s in 50 words",
},
],
temperature=0,
)
st.markdown("**LLM Response:**")
st.write(response["choices"][0]["message"]["content"].strip())
st.markdown("**Total tokens:**")
st.write(str(response["usage"]["total_tokens"]))
def class1_ex10():
st.subheader("Exercise 10: Basic Prompt Engineering")
st.markdown("""
Now, we are going to create a chatbot with a personality by using a default prompt for our chatbot. \n
This is the default prompt that will be used for every conversation.\n
Let's make it a chatbot that speaks like Yoda from Star Wars.\n
We will use the ***prompt_template*** that is already in our ***main()*** for this.
""")
st.code('''
if "prompt_template" not in st.session_state:
st.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"
''')
st.markdown("""
Run the code below. You should get the same chatbot behaviour as the code output below.\n
Try varying the temperature setting (0.0 to 1.0) to see how it affects the chatbot's response.\n
""")
st.markdown("**:blue[Code]**")
st.code('''
# Exercise 10: Basic prompt engineering
def ex10_basebot():
#prompt_template in session state already set in main()
MODEL = "gpt-3.5-turbo"
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": st.session_state.prompt_template},
{
"role": "user",
"content": "Tell me about Singapore in the 1970s in 50 words",
},
],
temperature=0,
)
st.markdown("**LLM Response:**")
st.write(response["choices"][0]["message"]["content"].strip())
st.markdown("**Total tokens:**")
st.write(str(response["usage"]["total_tokens"]))
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex10()
#Challenge 10
#mod chat complete stream function by replacing system content to session_state prompt template
def chat_completion_stream_prompt(prompt):
MODEL = "gpt-3.5-turbo" #consider changing this to session_state
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": st.session_state.prompt_template},
{"role": "user", "content": prompt},
],
temperature= 0, # temperature
stream=True #stream option
)
return response
# Challenge 10: Make the bot speak like someone you know
def ch10():
#call the function in your base bot
#Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
#Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
#set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
#streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
except Exception as e:
st.error(e)
def class1_ch10():
st.subheader("Challenge 10: Make your bot like someone you know!")
st.write("Modify the ***prompt_template*** in your ***main()*** to your own liking.")
st.write("Be imaginative!")
st.write("Now, in new function called **chat_completion_stream_prompt()**, we are going to modify the earlier **streaming chat_completion** function to accept a user prompt input.")
st.write("You will need to pass in a new input variable called **prompt** and replace the user content with the new **prompt** variable.")
st.write("Replace the system prompt with **st.session_state.prompt_template**.")
st.write("Before calling **chat_completion_stream_prompt()**, get a new prompt from the user like this to update the **st.session_state.prompt_template**:")
st.code('''
if my_prompt_template := st.text_input("Enter a system prompt template. E.g. Speak like Yoda from Star Wars."):
st.session_state.prompt_template = my_prompt_template
st.write("new prompt template set! ", st.session_state.prompt_template)
''')
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
#Challenge 10
#mod chat complete stream function by replacing system content to session_state prompt template
def chat_completion_stream_prompt(prompt):
MODEL = "gpt-3.5-turbo" #consider changing this to session_state
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": st.session_state.prompt_template},
{"role": "user", "content": prompt},
],
temperature= 0, # temperature
stream=True #stream option
)
return response
# Challenge 10: Make the bot speak like someone you know
def ch10_basebot():
# call the function in your base bot
# Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
# Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
#set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
#streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
except Exception as e:
st.error(e)
''')
st.markdown("**:red[Code Output]**")
st.title("ChatGPT-like clone with Prompt Engineering")
ch10()
#https://python.langchain.com/docs/modules/chains/
def ex11a(): # change in ex11a
# langchain prompt template
prompt = PromptTemplate(
input_variables=["subject", "topic"],
template="""Design a lesson plan on {subject} on the topic of {topic} for primary 1 students""",
)
# openai_api_key = st.secrets["openapi_key"]
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.9)
# creating a LLM chain with the langchain call and prompt template
chain = LLMChain(llm=llm, prompt=prompt)
if st.button("Run my chain"):
input_prompt = prompt.format(subject="English", topic="Verbs")
# Showing what is sent to LLM Chain
st.write("Input prompt: ", input_prompt)
# Showing the output from LLM Chain
st.write(chain.run({"subject": "English", "topic": "Verbs"}))
def class1_ex11a():
st.subheader("Exercise 11a: Prompt Template with LangChain")
st.write("LangChain helps you to create a more complext prompt template for your chatbot.")
st.markdown("**:blue[Code]**")
st.code('''
#https://python.langchain.com/docs/modules/chains/
def ex11a(): # change in ex11a
# langchain prompt template
prompt = PromptTemplate(
input_variables=["subject", "topic"],
template="""Design a lesson plan on {subject} on the topic of {topic} for primary 1 students""",
)
# openai_api_key = st.secrets["openapi_key"]
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.9)
# creating a LLM chain with the langchain call and prompt template
chain = LLMChain(llm=llm, prompt=prompt)
if st.button("Run my chain"):
input_prompt = prompt.format(subject="English", topic="Verbs")
# Showing what is sent to LLM Chain
st.write("Input prompt: ", input_prompt)
# Showing the output from LLM Chain
st.write(chain.run({"subject": "English", "topic": "Verbs"}))
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex11a()
def prompt_inputs_form(): #Using st.form, create the starting prompt to your prompt template, this is an expert on a topic that is talking to a user of a certain age
#langchain prompt template
with st.form("Prompt Template"):
occupation = st.text_input("Enter the occupation:")
topic = st.text_input("Enter the topic:")
age = st.text_input("Enter the age:")
# Every form must have a submit button.
submitted = st.form_submit_button("Submit")
#return a dictionary of the values
if submitted:
return {
'occupation': occupation,
'topic': topic,
'age': age
}
def ex11b():
# create your template
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
# create a langchain function call to openai
llm = ChatOpenAI(
model_name="gpt-3.5-turbo",
temperature=0.9,
)
# create a LLM chain with the langchain call and prompt template
chain = LLMChain(llm=llm, prompt=prompt_template)
# call the prompt_inputs_form()
dict_inputs = prompt_inputs_form()
if dict_inputs:
st.write(chain.run(dict_inputs))
def class1_ex11b():
st.subheader("Exercise 11b")
st.write("Now, we will create a chatbot with a prompt template that is more complex.")
st.write("We will use the ***prompt_inputs_form()*** function to get the user's input for the prompt template.")
st.write("Run the code below to see the chatbot in action.")
st.markdown("**:blue[Code]**")
st.code('''
def prompt_inputs_form(): # Using st.form, create the starting prompt to your prompt template, this is an expert on a topic that is talking to a user of a certain age
# langchain prompt template
with st.form("Prompt Template"):
occupation = st.text_input("Enter the occupation:")
topic = st.text_input("Enter the topic:")
age = st.text_input("Enter the age:")
# Every form must have a submit button.
submitted = st.form_submit_button("Submit")
# return a dictionary of the values
if submitted:
return {"occupation": occupation, "topic": topic, "age": age}
def ex11b():
# create your template
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
# create a langchain function call to openai
llm = ChatOpenAI(
model_name="gpt-3.5-turbo",
temperature=0.9,
)
# create a LLM chain with the langchain call and prompt template
chain = LLMChain(llm=llm, prompt=prompt_template)
# call the prompt_inputs_form()
dict_inputs = prompt_inputs_form()
if dict_inputs:
st.write(chain.run(dict_inputs))
''')
st.markdown("**:red[Code Output]**")
# Actual code here
ex11b()
def ch11():
# instead of running of the langchain, we are going to use the prompt template and run it the chatbot using format
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
# set session_state.prompt_template
st.session_state.prompt_template = input_prompt
st.write("New session_state.prompt_template: ", input_prompt)
# call ch10() with the new session_state.prompt_template
ch10()
def class1_ch11():
st.subheader("Challenge 11: Prompt Template with LangChain")
st.write("Now, let's incorporate the prompt template into our chatbot from the previous exercise.")
st.write("We will use the ***prompt_inputs_form()*** function to get the user's input for the prompt template.")
st.write("You can use the ***ch10*** function from the previous exercise to do the llm api call with the updated session_state.prompt_template.")
st.write("Ignore the text input field that asks for a system prompt template from ch10(), since we will be using the prompt template from the user's input.")
st.write("As you interact with the chatbot, observe that the prompt template is updated with the latest user input as seen from the code output.")
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
def ch11():
# instead of running of the langchain, we are going to use the prompt template and run it the chatbot using format
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
# set session_state.prompt_template
st.session_state.prompt_template = input_prompt
st.write("New session_state.prompt_template: ", input_prompt)
# call the ch10() basebot with the new session_state.prompt_template
ch10()
''')
st.markdown("**:red[Code Output]**")
# actual code here
ch11()
def ex12():
memory = ConversationBufferWindowMemory(k=3)
memory.save_context({"input": "hi"}, {"output": "whats up?"})
memory.save_context({"input": "not much"}, {"output": "what can I help you with?"})
st.write(memory.load_memory_variables({}))
memory = ConversationBufferWindowMemory( k=3, return_messages=True)
memory.save_context({"input": "hi"}, {"output": "whats up?"})
memory.save_context({"input": "not much"}, {"output": "what can I help you with?"})
st.write(memory.load_memory_variables({}))
def class1_ex12():
st.subheader("Exercise 12: Chatbot with memory")
st.write("Now, we will create a chatbot with memory.")
st.write("You can determine the number of previous messages to remember by setting the ***k*** parameter.")
st.markdown("**:blue[Code]**")
st.code('''
def ex12():
memory = ConversationBufferWindowMemory(k=3)
memory.save_context({"input": "hi"}, {"output": "whats up?"})
memory.save_context({"input": "not much"}, {"output": "what can I help you with?"})
st.write(memory.load_memory_variables({}))
memory = ConversationBufferWindowMemory( k=3, return_messages=True)
memory.save_context({"input": "hi"}, {"output": "whats up?"})
memory.save_context({"input": "not much"}, {"output": "what can I help you with?"})
st.write(memory.load_memory_variables({}))
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex12()
def ch12():
# Prompt_template form from ex11
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information
to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
else:
input_prompt = "You are a helpful assistant. "
st.write("input prompt: ", input_prompt)
if "memory" not in st.session_state:
st.session_state.memory = ConversationBufferWindowMemory(k=3)
# step 1 save the memory from your chatbot
# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint
memory_data = st.session_state.memory.load_memory_variables({})
st.write("Memory Data: ", memory_data)
st.session_state.prompt_template = f"""
{input_prompt}
Below is the conversation history between the AI and Users so far
{memory_data}
"""
st.write("New prompt template:", st.session_state.prompt_template)
# call the function in your base bot
# Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
# Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
st.session_state.memory.save_context(
{"input": prompt}, {"output": full_response}
)
except Exception as e:
st.error(e)
def class1_ch12():
st.subheader("Challenge 12: Chatbot with memory")
st.write("Now, let's incorporate the memory into the session state prompt template.")
st.write("The chatbot should remember the previous user input and use it as the prompt template for the next conversation.")
st.write("Start with the following code and modify ex12() to create a chatbot with memory.")
st.write("Get the *{input_prompt}* using *prompt_inputs_form()*.")
st.write("As you interact with the chatbot, observe that the memory is updated with the latest k number of user input and output as seen from the code output.")
st.markdown("**:blue[Code]**")
st.code('''
if "memory" not in st.session_state:
st.session_state.memory = ConversationBufferWindowMemory(k=5)
#step 1 save the memory from your chatbot
#step 2 integrate the memory in the prompt_template (st.session_state.prompt_template)
memory_data = st.session_state.memory.load_memory_variables({})
st.write(memory_data)
st.session_state.prompt_template = f"""{input_prompt}\n\nBelow is the conversation history between the AI and Users so far\n\n{memory_data}"""
''')
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
def ch12():
# Prompt_template form from ex11
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information
to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
else:
input_prompt = "You are a helpful assistant. "
st.write("input prompt: ", input_prompt)
if "memory" not in st.session_state:
st.session_state.memory = ConversationBufferWindowMemory(k=3)
# step 1 save the memory from your chatbot
# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint
memory_data = st.session_state.memory.load_memory_variables({})
st.write("Memory Data: ", memory_data)
st.session_state.prompt_template = f"""
{input_prompt}
Below is the conversation history between the AI and Users so far
{memory_data}
"""
st.write("New prompt template: ", st.session_state.prompt_template)
# call the function in your base bot
# Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
# Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
st.session_state.memory.save_context(
{"input": prompt}, {"output": full_response}
)
except Exception as e:
st.error(e)
''')
st.markdown("**:red[Code Output]**")
#actual code here
ch12()
#exercise 13 - loading
def upload_file_streamlit():
def get_file_extension(file_name):
return os.path.splitext(file_name)[1]
st.subheader("Upload your docs")
# Streamlit file uploader to accept file input
uploaded_file = st.file_uploader("Choose a file", type=["docx", "txt", "pdf"])
if uploaded_file:
# Reading file content
file_content = uploaded_file.read()
# Determine the suffix based on uploaded file's name
file_suffix = get_file_extension(uploaded_file.name)
# Saving the uploaded file temporarily to process it
with tempfile.NamedTemporaryFile(delete=False, suffix=file_suffix) as temp_file:
temp_file.write(file_content)
temp_file.flush() # Ensure the data is written to the file
temp_file_path = temp_file.name
return temp_file_path
#exercise 13 - split and chunk, embeddings and storing in vectorstores for reference
def vectorstore_creator():
# WORKING_DIRECTORY set above in the main.py
# Process the temporary file using UnstructuredFileLoader (or any other method you need)
embeddings = OpenAIEmbeddings()
db = lancedb.connect(WORKING_DIRECTORY)
table = db.create_table(
"my_table",
data=[
{
"vector": embeddings.embed_query("Query unsuccessful"),
"text": "Query unsuccessful",
"id": "1",
}
],
mode="overwrite",
)
# st.write(temp_file_path)
temp_file_path = upload_file_streamlit()
if temp_file_path:
loader = PyPDFLoader(temp_file_path)
documents = loader.load_and_split()
db = LanceDB.from_documents(documents, embeddings, connection=table)
return db
def ex13_vectorstore_creator():
if "vectorstore" not in st.session_state:
st.session_state.vectorstore = False
db = vectorstore_creator()
st.session_state.vectorstore = db
if st.session_state.vectorstore:
query = st.text_input("Enter a query")
if query:
st.session_state.vectorstore = db
docs = db.similarity_search(query)
st.write(docs[0].page_content)
def class1_ex13():
st.subheader("Exercise 13: Create a vector store")
st.write("Now, we will create a vector store to store the user's document.")
st.write("This process uses OpenAI to generate embeddings and LanceDB for storing these embeddings.")
st.write("For now, this only works for pdf files.")
st.write("You may need to run the following commands in terminal to install new libaries:")
st.code('''
pip install tiktoken
''')
st.markdown("**:blue[Code]**")
st.code('''
#exercise 13 - loading
def upload_file_streamlit():
def get_file_extension(file_name):
return os.path.splitext(file_name)[1]
st.subheader("Upload your docs")
# Streamlit file uploader to accept file input
uploaded_file = st.file_uploader("Choose a file", type=["docx", "txt", "pdf"])
if uploaded_file:
# Reading file content
file_content = uploaded_file.read()
# Determine the suffix based on uploaded file's name
file_suffix = get_file_extension(uploaded_file.name)
# Saving the uploaded file temporarily to process it
with tempfile.NamedTemporaryFile(delete=False, suffix=file_suffix) as temp_file:
temp_file.write(file_content)
temp_file.flush() # Ensure the data is written to the file
temp_file_path = temp_file.name
return temp_file_path
#exercise 13 - split and chunk, embeddings and storing in vectorstores for reference
def vectorstore_creator():
# WORKING_DIRECTORY set above in the main.py
# Process the temporary file using UnstructuredFileLoader (or any other method you need)
embeddings = OpenAIEmbeddings()
db = lancedb.connect(WORKING_DIRECTORY)
table = db.create_table(
"my_table",
data=[
{
"vector": embeddings.embed_query("Query unsuccessful"),
"text": "Query unsuccessful",
"id": "1",
}
],
mode="overwrite",
)
# st.write(temp_file_path)
temp_file_path = upload_file_streamlit()
if temp_file_path:
loader = PyPDFLoader(temp_file_path)
documents = loader.load_and_split()
db = LanceDB.from_documents(documents, embeddings, connection=table)
return db
def ex13_vectorstore_creator():
if "vectorstore" not in st.session_state:
st.session_state.vectorstore = False
db = vectorstore_creator()
st.session_state.vectorstore = db
if st.session_state.vectorstore:
query = st.text_input("Enter a query")
if query:
st.session_state.vectorstore = db
docs = db.similarity_search(query)
st.write(docs[0].page_content)
''')
st.markdown("**:red[Code Output]**")
ex13_vectorstore_creator()
# save the vectorstore in st.session_state
# add semantic search prompt into memory prompt
# integrate back into your chatbot
def ex14():
# Prompt_template form from ex11
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information
to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
st.session_state.input_prompt = input_prompt
if "input_prompt" not in st.session_state:
st.session_state.input_prompt = "Speak like Yoda from Star Wars"
if "memory" not in st.session_state:
st.session_state.memory = ConversationBufferWindowMemory(k=5)
# step 1 save the memory from your chatbot
# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint
memory_data = st.session_state.memory.load_memory_variables({})
st.write(memory_data)
st.session_state.prompt_template = f"""
st.session_state.input_prompt: {st.session_state.input_prompt}
This is the last conversation history
{memory_data}
"""
st.write("new prompt template: ", st.session_state.prompt_template)
st.session_state.vectorstore = vectorstore_creator()
# Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
# Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# query information
if st.session_state.vectorstore:
docs = st.session_state.vectorstore.similarity_search(prompt)
docs = docs[0].page_content
# add your query prompt
vs_prompt = f"""You should reference this search result to help your answer,
{docs}
if the search result does not anwer the query, please say you are unable to answer, do not make up an answer"""
else:
vs_prompt = ""
# add query prompt to your memory prompt and send it to LLM
st.session_state.prompt_template = (
st.session_state.prompt_template + vs_prompt
)
# set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
st.session_state.memory.save_context(
{"input": prompt}, {"output": full_response}
)
except Exception as e:
st.error(e)
def class1_ex14():
st.subheader("Exercise 14: Semantic search")
st.write("In this exercise. we will do a semantic search on the vector store in our chatbot.")
st.write("At the same time, the chatbot is able to remember its conversation history to some extent.")
st.write("This code integrates advanced features like semantic search and context-aware prompts to provide a more engaging and helpful conversational experience.")
st.write("Copy and run the code below to see the chatbot in action.")
st.markdown("**:blue[Code]**")
st.code('''
# save the vectorstore in st.session_state
# add semantic search prompt into memory prompt
# integrate back into your chatbot
def ex14_basebot():
# Prompt_template form from ex11
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information
to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
st.session_state.input_prompt = input_prompt
if "input_prompt" not in st.session_state:
st.session_state.input_prompt = "Speak like Yoda from Star Wars"
if "memory" not in st.session_state:
st.session_state.memory = ConversationBufferWindowMemory(k=5)
# step 1 save the memory from your chatbot
# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint
memory_data = st.session_state.memory.load_memory_variables({})
st.write(memory_data)
st.session_state.prompt_template = f"""
{st.session_state.input_prompt}
This is the last conversation history:
{memory_data}"""
st.write("new prompt template: ", st.session_state.prompt_template)
st.session_state.vectorstore = vectorstore_creator()
# Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
# Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# query information
if st.session_state.vectorstore:
docs = st.session_state.vectorstore.similarity_search(prompt)
docs = docs[0].page_content
# add your query prompt
vs_prompt = f"""
You should reference this search result to help your answer,
{docs}
if the search result does not anwer the query, please say you are unable to answer, do not make up an answer"""
else:
vs_prompt = ""
# add query prompt to your memory prompt and send it to LLM
st.session_state.prompt_template = (
st.session_state.prompt_template + vs_prompt
)
# set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
st.session_state.memory.save_context(
{"input": prompt}, {"output": full_response}
)
except Exception as e:
st.error(e)
''')
st.markdown("**:red[Code Output]**")
#actual code here
ex14()
def ex15_initialise():
# Create or check for the 'database' directory in the current working directory
# Set DB_NAME to be within the 'database' directory at the top of main.py
# Connect to the SQLite database
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
# Conversation data table
cursor.execute(
"""
CREATE TABLE IF NOT EXISTS data_table (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL UNIQUE,
username TEXT NOT NULL,
chatbot_ans TEXT NOT NULL,
user_prompt TEXT NOT NULL,
tokens TEXT
)
"""
)
conn.commit()
conn.close()
def ex15_collect(username, chatbot_response, prompt):
# collect data from bot
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
now = datetime.now() # Using ISO format for date
tokens = len(chatbot_response) * 1.3
cursor.execute(
"""
INSERT INTO data_table (date, username,chatbot_ans, user_prompt, tokens)
VALUES (?, ?, ?, ?, ?)
""",
(now, username, chatbot_response, prompt, tokens),
)
conn.commit()
conn.close()
# implementing data collection and displaying
def ex15():
# initialise database first
ex15_initialise()
# collect some data
ex15_collect("yoda", "I am Yoda. The Force is strong with you", "Who are you?")
# display data
# Connect to the specified database
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
# Fetch all data from data_table
cursor.execute("SELECT * FROM data_table")
rows = cursor.fetchall()
column_names = [description[0] for description in cursor.description]
df = pd.DataFrame(rows, columns=column_names)
st.dataframe(df)
conn.close()
def class1_ex15():
st.subheader("Exercise 15: Using a database")
st.write("In this exercise, we will demonstrate how to create a database, as well as how to store and retrieve data from it.")
st.markdown("**:blue[Code]**")
st.code('''
def ex15_initialise():
# Create or check for the 'database' directory in the current working directory
# Set DB_NAME to be within the 'database' directory at the top of main.py
# Connect to the SQLite database
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
# Conversation data table
cursor.execute(
"""
CREATE TABLE IF NOT EXISTS data_table (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL UNIQUE,
username TEXT NOT NULL,
chatbot_ans TEXT NOT NULL,
user_prompt TEXT NOT NULL,
tokens TEXT
)
"""
)
conn.commit()
conn.close()
def ex15_collect(username, chatbot_response, prompt):
# collect data from bot
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
now = datetime.now() # Using ISO format for date
tokens = len(chatbot_response) * 1.3
cursor.execute(
"""
INSERT INTO data_table (date, username,chatbot_ans, user_prompt, tokens)
VALUES (?, ?, ?, ?, ?)
""",
(now, username, chatbot_response, prompt, tokens),
)
conn.commit()
conn.close()
# implementing data collection and displaying
def ex15():
# initialise database first
ex15_initialise()
# collect some data
ex15_collect("yoda", "I am Yoda. The Force is strong with you", "Who are you?")
# display data
# Connect to the specified database
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
# Fetch all data from data_table
cursor.execute("SELECT * FROM data_table")
rows = cursor.fetchall()
column_names = [description[0] for description in cursor.description]
df = pd.DataFrame(rows, columns=column_names)
st.dataframe(df)
conn.close()
''')
st.markdown("**:red[Code Output]**")
# Actual code here
ex15()
def ch15_chatbot():
#display ex15 table
ex15()
# Prompt_template form from ex11
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information
to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
st.session_state.input_prompt = input_prompt
if "input_prompt" not in st.session_state:
st.session_state.input_prompt = "Speak like Yoda from Star Wars"
if "memory" not in st.session_state:
st.session_state.memory = ConversationBufferWindowMemory(k=5)
# step 1 save the memory from your chatbot
# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint
memory_data = st.session_state.memory.load_memory_variables({})
st.write(memory_data)
st.session_state.prompt_template = f"""{st.session_state.input_prompt}
This is the last conversation history
{memory_data}
"""
st.write("new prompt template: ", st.session_state.prompt_template)
st.session_state.vectorstore = vectorstore_creator()
# Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
# Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# query information
if st.session_state.vectorstore:
docs = st.session_state.vectorstore.similarity_search(prompt)
docs = docs[0].page_content
# add your query prompt
vs_prompt = f"""You should reference this search result to help your answer,
{docs}
if the search result does not anwer the query, please say you are unable to answer, do not make up an answer"""
else:
vs_prompt = ""
# add query prompt to your memory prompt and send it to LLM
st.session_state.prompt_template = (
st.session_state.prompt_template + vs_prompt
)
# set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
st.session_state.memory.save_context(
{"input": prompt}, {"output": full_response}
)
ex15_collect(st.session_state.name, full_response, prompt)
except Exception as e:
st.error(e)
def class1_ch15():
st.subheader("Challenge 15: Using a database")
st.write("For this challenge, we will incorporate using a database from our previous exercise.")
st.write("Copy the code from ***ex14()*** and use the ***ex15()*** to collect and display the data.")
st.markdown("**:blue[Code]**")
with st.expander("Reveal Code"):
st.code('''
def ch15_chatbot():
#display ex15 table
ex15()
# Prompt_template form from ex11
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information
to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
st.session_state.input_prompt = input_prompt
if "input_prompt" not in st.session_state:
st.session_state.input_prompt = "Speak like Yoda from Star Wars"
if "memory" not in st.session_state:
st.session_state.memory = ConversationBufferWindowMemory(k=5)
# step 1 save the memory from your chatbot
# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint
memory_data = st.session_state.memory.load_memory_variables({})
st.write(memory_data)
st.session_state.prompt_template = f"""{st.session_state.input_prompt}
This is the last conversation history
{memory_data}
"""
st.write("new prompt template: ", st.session_state.prompt_template)
st.session_state.vectorstore = vectorstore_creator()
# Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
# Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# query information
if st.session_state.vectorstore:
docs = st.session_state.vectorstore.similarity_search(prompt)
docs = docs[0].page_content
# add your query prompt
vs_prompt = f"""You should reference this search result to help your answer,
{docs}
if the search result does not anwer the query, please say you are unable to answer, do not make up an answer"""
else:
vs_prompt = ""
# add query prompt to your memory prompt and send it to LLM
st.session_state.prompt_template = (
st.session_state.prompt_template + vs_prompt
)
# set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
st.session_state.memory.save_context(
{"input": prompt}, {"output": full_response}
)
ex15_collect(st.session_state.name, full_response, prompt)
except Exception as e:
st.error(e)
''')
st.markdown("**:red[Code Output]**")
# Actual code here
ch15_chatbot()
# smart agents accessing the internet for free
# https://github.com/langchain-ai/streamlit-agent/blob/main/streamlit_agent/search_and_chat.py
def ex16():
st.title("🦜 LangChain: Chat with internet search")
msgs = StreamlitChatMessageHistory()
memory = ConversationBufferMemory(
chat_memory=msgs,
return_messages=True,
memory_key="chat_history",
output_key="output",
)
if len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):
msgs.clear()
msgs.add_ai_message("How can I help you?")
st.session_state.steps = {}
avatars = {"human": "user", "ai": "assistant"}
for idx, msg in enumerate(msgs.messages):
with st.chat_message(avatars[msg.type]):
# Render intermediate steps if any were saved
for step in st.session_state.steps.get(str(idx), []):
if step[0].tool == "_Exception":
continue
with st.status(
f"**{step[0].tool}**: {step[0].tool_input}", state="complete"
):
st.write(step[0].log)
st.write(step[1])
st.write(msg.content)
if prompt := st.chat_input(placeholder="Enter a query on the Internet"):
st.chat_message("user").write(prompt)
llm = ChatOpenAI(
model_name="gpt-3.5-turbo", openai_api_key=openai.api_key, streaming=True
)
tools = [DuckDuckGoSearchRun(name="Search")]
chat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)
executor = AgentExecutor.from_agent_and_tools(
agent=chat_agent,
tools=tools,
memory=memory,
return_intermediate_steps=True,
handle_parsing_errors=True,
)
with st.chat_message("assistant"):
st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
response = executor(prompt, callbacks=[st_cb])
st.write(response["output"])
st.session_state.steps[str(len(msgs.messages) - 1)] = response[
"intermediate_steps"
]
def class1_ex16():
st.subheader("Exercise 16: Smart agent")
st.write("In this exercise, we will configure a chatbot with an internet search tool that shows all intermediate steps and tool logs.")
st.write("This overcomes the limitation of the training data that is only up to a certain point in time, by being able to access the current internet to search for answers.")
st.write("You may need to run the following commands in terminal to install new libaries:")
st.code('''
pip install duckduckgo-search
''')
st.markdown("**:blue[Code]**")
st.code('''
# smart agents accessing the internet for free
# https://github.com/langchain-ai/streamlit-agent/blob/main/streamlit_agent/search_and_chat.py
def ex16_agent_bot():
st.title("🦜 LangChain: Chat with internet search")
msgs = StreamlitChatMessageHistory()
memory = ConversationBufferMemory(
chat_memory=msgs,
return_messages=True,
memory_key="chat_history",
output_key="output",
)
if len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):
msgs.clear()
msgs.add_ai_message("How can I help you?")
st.session_state.steps = {}
avatars = {"human": "user", "ai": "assistant"}
for idx, msg in enumerate(msgs.messages):
with st.chat_message(avatars[msg.type]):
# Render intermediate steps if any were saved
for step in st.session_state.steps.get(str(idx), []):
if step[0].tool == "_Exception":
continue
with st.status(
f"**{step[0].tool}**: {step[0].tool_input}", state="complete"
):
st.write(step[0].log)
st.write(step[1])
st.write(msg.content)
if prompt := st.chat_input(placeholder="Enter a query on the Internet"):
st.chat_message("user").write(prompt)
llm = ChatOpenAI(
model_name="gpt-3.5-turbo", openai_api_key=openai_api_key, streaming=True
)
tools = [DuckDuckGoSearchRun(name="Search")]
chat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)
executor = AgentExecutor.from_agent_and_tools(
agent=chat_agent,
tools=tools,
memory=memory,
return_intermediate_steps=True,
handle_parsing_errors=True,
)
with st.chat_message("assistant"):
st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
response = executor(prompt, callbacks=[st_cb])
st.write(response["output"])
st.session_state.steps[str(len(msgs.messages) - 1)] = response[
"intermediate_steps"
]
''')
st.markdown("**:red[Code Output]**")
# Actual code here
ex16()
# agents ,vectorstores, wiki
# https://python.langchain.com/docs/modules/agents/how_to/custom_agent_with_tool_retrieval
# note tool
@tool("Document search")
def document_search(query: str) -> str:
# this is the prompt to the tool itself
"Use this function first to search for documents pertaining to the query before going into the internet"
docs = st.session_state.vectorstore.similarity_search(query)
docs = docs[0].page_content
json_string = json.dumps(docs, ensure_ascii=False, indent=4)
return json_string
# combine vector store and internet search
def ex17():
st.title("🦜 LangChain: Chat with internet search")
st.session_state.vectorstore = vectorstore_creator()
msgs = StreamlitChatMessageHistory()
memory = ConversationBufferMemory(
chat_memory=msgs,
return_messages=True,
memory_key="chat_history",
output_key="output",
)
if len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):
msgs.clear()
msgs.add_ai_message("How can I help you?")
st.session_state.steps = {}
avatars = {"human": "user", "ai": "assistant"}
for idx, msg in enumerate(msgs.messages):
with st.chat_message(avatars[msg.type]):
# Render intermediate steps if any were saved
for step in st.session_state.steps.get(str(idx), []):
if step[0].tool == "_Exception":
continue
with st.status(
f"**{step[0].tool}**: {step[0].tool_input}", state="complete"
):
st.write(step[0].log)
st.write(step[1])
st.write(msg.content)
if prompt := st.chat_input(placeholder="Enter a query on the Internet"):
st.chat_message("user").write(prompt)
llm = ChatOpenAI(
model_name="gpt-3.5-turbo", openai_api_key=openai.api_key, streaming=True
)
tools = [document_search, DuckDuckGoSearchRun(name="Internet Search")]
chat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)
executor = AgentExecutor.from_agent_and_tools(
agent=chat_agent,
tools=tools,
memory=memory,
return_intermediate_steps=True,
handle_parsing_errors=True,
)
with st.chat_message("assistant"):
st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
response = executor(prompt, callbacks=[st_cb])
st.write(response["output"])
st.session_state.steps[str(len(msgs.messages) - 1)] = response[
"intermediate_steps"
]
def class1_ex17():
st.subheader("Exercise 17: Smart agent with vector store")
st.write("In this exercise, we will combine the vector store with the smart agent.")
st.write("This allows the chatbot to search for answers from the vector store and the internet.")
st.write("The @tool(\"Document search\") function is an enhancement to the chatbot. It allows for an initial internal document search based on the user query before resorting to external internet searches. ")
st.write("Copy and run the code below to see the chatbot in action.")
st.markdown("**:blue[Code]**")
st.code('''
# agents ,vectorstores, wiki
# https://python.langchain.com/docs/modules/agents/how_to/custom_agent_with_tool_retrieval
# note tool
@tool("Document search")
def document_search(query: str) -> str:
# this is the prompt to the tool itself
"Use this function first to search for documents pertaining to the query before going into the internet"
docs = st.session_state.vectorstore.similarity_search(query)
docs = docs[0].page_content
json_string = json.dumps(docs, ensure_ascii=False, indent=4)
return json_string
# combine vector store and internet search
def ex17_agent_bot():
st.title("🦜 LangChain: Chat with internet search")
st.session_state.vectorstore = vectorstore_creator()
msgs = StreamlitChatMessageHistory()
memory = ConversationBufferMemory(
chat_memory=msgs,
return_messages=True,
memory_key="chat_history",
output_key="output",
)
if len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):
msgs.clear()
msgs.add_ai_message("How can I help you?")
st.session_state.steps = {}
avatars = {"human": "user", "ai": "assistant"}
for idx, msg in enumerate(msgs.messages):
with st.chat_message(avatars[msg.type]):
# Render intermediate steps if any were saved
for step in st.session_state.steps.get(str(idx), []):
if step[0].tool == "_Exception":
continue
with st.status(
f"**{step[0].tool}**: {step[0].tool_input}", state="complete"
):
st.write(step[0].log)
st.write(step[1])
st.write(msg.content)
if prompt := st.chat_input(placeholder="Enter a query on the Internet"):
st.chat_message("user").write(prompt)
llm = ChatOpenAI(
model_name="gpt-3.5-turbo", openai_api_key=openai_api_key, streaming=True
)
tools = [document_search, DuckDuckGoSearchRun(name="Internet Search")]
chat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)
executor = AgentExecutor.from_agent_and_tools(
agent=chat_agent,
tools=tools,
memory=memory,
return_intermediate_steps=True,
handle_parsing_errors=True,
)
with st.chat_message("assistant"):
st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
response = executor(prompt, callbacks=[st_cb])
st.write(response["output"])
st.session_state.steps[str(len(msgs.messages) - 1)] = response[
"intermediate_steps"
]
''')
st.markdown("**:red[Code Output]**")
# Actual code here
ex17()
# PandasAI- A smart agent that can do visual analytics
def ex18():
st.title("pandas-ai streamlit interface")
# Upload CSV file using st.file_uploader
uploaded_file = st.file_uploader("Choose a CSV file", type="csv")
if "openai_key" not in st.session_state:
st.session_state.openai_key = st.secrets["openapi_key"]
st.session_state.prompt_history = []
st.session_state.df = None
if uploaded_file is not None:
try:
df = pd.read_csv(uploaded_file)
st.session_state.df = df
except Exception as e:
st.write("There was an error processing the CSV file.")
st.write(e)
else:
st.session_state.df = pd.DataFrame(
{
"country": [
"United States",
"United Kingdom",
"France",
"Germany",
"Italy",
"Spain",
"Canada",
"Australia",
"Japan",
"China",
],
"gdp": [
19294482071552,
2891615567872,
2411255037952,
3435817336832,
1745433788416,
1181205135360,
1607402389504,
1490967855104,
4380756541440,
14631844184064,
],
"happiness_index": [
6.94,
7.16,
6.66,
7.07,
6.38,
6.4,
7.23,
7.22,
5.87,
5.12,
],
}
)
chart_path = os.path.join("exports/charts")
with st.form("Question"):
question = st.text_input("Question", value="", type="default")
submitted = st.form_submit_button("Submit")
if submitted:
with st.spinner():
llm = OpenAI(api_token=st.session_state.openai_key)
df = SmartDataframe(
st.session_state.df,
config={
"llm": llm,
"save_charts_path": chart_path,
"save_charts": True,
"verbose": True,
},
)
response = df.chat(
question
) # Using 'chat' method based on your context
# Display the textual response (if any):
if response:
st.write(response)
chart_path = os.path.join("exports/charts", "temp_chart.png")
if os.path.exists(chart_path):
st.image(
chart_path, caption="Generated Chart", use_column_width=True
)
# Append the question to the history:
st.session_state.prompt_history.append(question)
if st.session_state.df is not None:
st.subheader("Current dataframe:")
st.write(st.session_state.df)
st.subheader("Prompt history:")
st.write(st.session_state.prompt_history)
if st.button("Clear"):
st.session_state.prompt_history = []
st.session_state.df = None
def class1_ex18():
st.subheader("Exercise 18: Data Analytics")
st.write("In this exercise, we will use the Pandas AI library to perform data analytics.")
st.write("The Pandas AI library is a smart agent that can perform data analytics on a dataframe.")
st.write("You may need to install the following library:")
st.code('''pip install bs4''')
st.write("Copy and run the code below to see the chatbot in action.")
st.markdown("**:blue[Code]**")
st.code('''
# PandasAI- A smart agent that can do visual analytics
def ex18_pandas_AI():
st.title("pandas-ai streamlit interface")
# Upload CSV file using st.file_uploader
uploaded_file = st.file_uploader("Choose a CSV file", type="csv")
if "openai_key" not in st.session_state:
st.session_state.openai_key = st.secrets["openapi_key"]
st.session_state.prompt_history = []
st.session_state.df = None
if uploaded_file is not None:
try:
df = pd.read_csv(uploaded_file)
st.session_state.df = df
except Exception as e:
st.write("There was an error processing the CSV file.")
st.write(e)
else:
st.session_state.df = pd.DataFrame(
{
"country": [
"United States",
"United Kingdom",
"France",
"Germany",
"Italy",
"Spain",
"Canada",
"Australia",
"Japan",
"China",
],
"gdp": [
19294482071552,
2891615567872,
2411255037952,
3435817336832,
1745433788416,
1181205135360,
1607402389504,
1490967855104,
4380756541440,
14631844184064,
],
"happiness_index": [
6.94,
7.16,
6.66,
7.07,
6.38,
6.4,
7.23,
7.22,
5.87,
5.12,
],
}
)
chart_path = os.path.join("exports/charts")
with st.form("Question"):
question = st.text_input("Question", value="", type="default")
submitted = st.form_submit_button("Submit")
if submitted:
with st.spinner():
llm = OpenAI(api_token=st.session_state.openai_key)
df = SmartDataframe(
st.session_state.df,
config={
"llm": llm,
"save_charts_path": chart_path,
"save_charts": True,
"verbose": True,
},
)
response = df.chat(
question
) # Using 'chat' method based on your context
# Display the textual response (if any):
if response:
st.write(response)
chart_path = os.path.join("exports/charts", "temp_chart.png")
if os.path.exists(chart_path):
st.image(
chart_path, caption="Generated Chart", use_column_width=True
)
# Append the question to the history:
st.session_state.prompt_history.append(question)
if st.session_state.df is not None:
st.subheader("Current dataframe:")
st.write(st.session_state.df)
st.subheader("Prompt history:")
st.write(st.session_state.prompt_history)
if st.button("Clear"):
st.session_state.prompt_history = []
st.session_state.df = None
''')
st.markdown("**:red[Code Output]**")
ex18() | [
"lancedb.connect"
] | [((1222, 1233), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1231, 1233), False, 'import os\n'), ((1254, 1283), 'os.path.join', 'os.path.join', (['cwd', '"""database"""'], {}), "(cwd, 'database')\n", (1266, 1283), False, 'import os\n'), ((1375, 1420), 'os.path.join', 'os.path.join', (['WORKING_DIRECTORY', '"""default_db"""'], {}), "(WORKING_DIRECTORY, 'default_db')\n", (1387, 1420), False, 'import os\n'), ((86756, 86779), 'langchain.agents.tool', 'tool', (['"""Document search"""'], {}), "('Document search')\n", (86760, 86779), False, 'from langchain.agents import tool\n'), ((1292, 1325), 'os.path.exists', 'os.path.exists', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (1306, 1325), False, 'import os\n'), ((1328, 1358), 'os.makedirs', 'os.makedirs', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (1339, 1358), False, 'import os\n'), ((1439, 1463), 'streamlit.subheader', 'st.subheader', (['"""Template"""'], {}), "('Template')\n", (1451, 1463), True, 'import streamlit as st\n'), ((1465, 1495), 'streamlit.write', 'st.write', (['"""Instruction lines."""'], {}), "('Instruction lines.')\n", (1473, 1495), True, 'import streamlit as st\n'), ((1498, 1528), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (1509, 1528), True, 'import streamlit as st\n'), ((1530, 1566), 'streamlit.code', 'st.code', (['"""\n#exercise code here\n"""'], {}), '("""\n#exercise code here\n""")\n', (1537, 1566), True, 'import streamlit as st\n'), ((1568, 1598), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (1579, 1598), True, 'import streamlit as st\n'), ((1677, 1713), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (1688, 1713), True, 'import streamlit as st\n'), ((1844, 1856), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (1854, 1856), True, 'import streamlit as st\n'), ((1858, 1892), 'streamlit.subheader', 'st.subheader', (['"""Pre-workshop Setup"""'], {}), "('Pre-workshop Setup')\n", (1870, 1892), True, 'import streamlit as st\n'), ((1910, 2088), 'streamlit.markdown', 'st.markdown', (['"""1. Visual Studio (VS Code): this is the Integrated Development Environment (IDE) of choice by many coders and will make it easier for us to code our app."""'], {}), "(\n '1. Visual Studio (VS Code): this is the Integrated Development Environment (IDE) of choice by many coders and will make it easier for us to code our app.'\n )\n", (1921, 2088), True, 'import streamlit as st\n'), ((2084, 2217), 'streamlit.markdown', 'st.markdown', (['"""2. Python (3.10 release or later): this is the coding language of choice for many data science related apps."""'], {}), "(\n '2. Python (3.10 release or later): this is the coding language of choice for many data science related apps.'\n )\n", (2095, 2217), True, 'import streamlit as st\n'), ((2213, 2621), 'streamlit.write', 'st.write', (['"""\n\t\t\t3. Once you have installed the above, we will need to set up a virtual environment and install the libraries in that environment.\n\n\t\t\t\tCreate a folder named “chatbot” anywhere, e.g. in your Desktop.\n \n\t\t\t\tOpen VS Code and navigate to the folder in a new terminal window.\n \n\t\t\t\tCreate a virtual environment and activate it by entering the following commands in the terminal:\n\t\t\t """'], {}), '(\n """\n\t\t\t3. Once you have installed the above, we will need to set up a virtual environment and install the libraries in that environment.\n\n\t\t\t\tCreate a folder named “chatbot” anywhere, e.g. in your Desktop.\n \n\t\t\t\tOpen VS Code and navigate to the folder in a new terminal window.\n \n\t\t\t\tCreate a virtual environment and activate it by entering the following commands in the terminal:\n\t\t\t """\n )\n', (2221, 2621), True, 'import streamlit as st\n'), ((2616, 2644), 'streamlit.markdown', 'st.markdown', (['""" **a) Mac**"""'], {}), "(' **a) Mac**')\n", (2627, 2644), True, 'import streamlit as st\n'), ((2646, 2716), 'streamlit.code', 'st.code', (['"""\n\t\tpython3 -m venv venv\n\t\tsource venv/bin/activate \n\t\t\t"""'], {}), '("""\n\t\tpython3 -m venv venv\n\t\tsource venv/bin/activate \n\t\t\t""")\n', (2653, 2716), True, 'import streamlit as st\n'), ((2718, 2796), 'streamlit.markdown', 'st.markdown', (['"""(You should see a (venv) appear in your terminal window prompt)"""'], {}), "('(You should see a (venv) appear in your terminal window prompt)')\n", (2729, 2796), True, 'import streamlit as st\n'), ((2798, 2814), 'streamlit.markdown', 'st.markdown', (['"""#"""'], {}), "('#')\n", (2809, 2814), True, 'import streamlit as st\n'), ((2816, 2848), 'streamlit.markdown', 'st.markdown', (['""" **b) Windows**"""'], {}), "(' **b) Windows**')\n", (2827, 2848), True, 'import streamlit as st\n'), ((2850, 2921), 'streamlit.code', 'st.code', (['"""\n\t\tpython -m venv venv\n\t\tcd venv\\\\Scripts\n\t\tactivate\n\t\t\t"""'], {}), '("""\n\t\tpython -m venv venv\n\t\tcd venv\\\\Scripts\n\t\tactivate\n\t\t\t""")\n', (2857, 2921), True, 'import streamlit as st\n'), ((2922, 3072), 'streamlit.markdown', 'st.markdown', (['"""4. While in your virtual environment, install the libraries using pip which should already be installed together with Python:"""'], {}), "(\n '4. While in your virtual environment, install the libraries using pip which should already be installed together with Python:'\n )\n", (2933, 3072), True, 'import streamlit as st\n'), ((3064, 3114), 'streamlit.code', 'st.code', (['"""\n\t\tpip install streamlit openai\n\t\t\t"""'], {}), '("""\n\t\tpip install streamlit openai\n\t\t\t""")\n', (3071, 3114), True, 'import streamlit as st\n'), ((3116, 3193), 'streamlit.markdown', 'st.markdown', (['""" To test if Streamlit is installed properly, run this command:"""'], {}), "(' To test if Streamlit is installed properly, run this command:')\n", (3127, 3193), True, 'import streamlit as st\n'), ((3195, 3231), 'streamlit.code', 'st.code', (['"""\n\tstreamlit hello\n\t\t\t"""'], {}), '("""\n\tstreamlit hello\n\t\t\t""")\n', (3202, 3231), True, 'import streamlit as st\n'), ((3233, 3325), 'streamlit.markdown', 'st.markdown', (['""" You should see a Streamlit application running at http://localhost:8501"""'], {}), "(\n ' You should see a Streamlit application running at http://localhost:8501')\n", (3244, 3325), True, 'import streamlit as st\n'), ((3322, 3397), 'streamlit.markdown', 'st.markdown', (['""" Type Ctrl + C in VS Code terminal to stop the Streamlit app"""'], {}), "(' Type Ctrl + C in VS Code terminal to stop the Streamlit app')\n", (3333, 3397), True, 'import streamlit as st\n'), ((3424, 3464), 'streamlit.subheader', 'st.subheader', (['"""My first Hello World app"""'], {}), "('My first Hello World app')\n", (3436, 3464), True, 'import streamlit as st\n'), ((3466, 3478), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (3476, 3478), True, 'import streamlit as st\n'), ((3480, 3533), 'streamlit.markdown', 'st.markdown', (['"""1. Create a new file called \'main.py\'."""'], {}), '("1. Create a new file called \'main.py\'.")\n', (3491, 3533), True, 'import streamlit as st\n'), ((3539, 3640), 'streamlit.markdown', 'st.markdown', (['"""2. Copy the code below and paste it in the newly created helloworld.py file."""'], {}), "(\n '2. Copy the code below and paste it in the newly created helloworld.py file.'\n )\n", (3550, 3640), True, 'import streamlit as st\n'), ((3636, 3666), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (3647, 3666), True, 'import streamlit as st\n'), ((3668, 3778), 'streamlit.code', 'st.code', (['"""\n\t\t\timport streamlit as st\n\t\t\t#my first Hello World app\n\t\t\tst.write("Hello World")\n\t\t"""'], {}), '(\n """\n\t\t\timport streamlit as st\n\t\t\t#my first Hello World app\n\t\t\tst.write("Hello World")\n\t\t"""\n )\n', (3675, 3778), True, 'import streamlit as st\n'), ((3770, 3868), 'streamlit.markdown', 'st.markdown', (['"""Install the watchdog module by running the command below in the terminal."""'], {}), "(\n 'Install the watchdog module by running the command below in the terminal.'\n )\n", (3781, 3868), True, 'import streamlit as st\n'), ((3860, 3891), 'streamlit.code', 'st.code', (['"""pip install watchdog"""'], {}), "('pip install watchdog')\n", (3867, 3891), True, 'import streamlit as st\n'), ((3893, 4030), 'streamlit.markdown', 'st.markdown', (['"""Now you don\'t have to keep restarting the app to see the changes you make to the code. Just refresh the browser."""'], {}), '(\n "Now you don\'t have to keep restarting the app to see the changes you make to the code. Just refresh the browser."\n )\n', (3904, 4030), True, 'import streamlit as st\n'), ((4022, 4123), 'streamlit.write', 'st.write', (['"""Save your file and run the app by typing the following command in the terminal:"""'], {}), "(\n 'Save your file and run the app by typing the following command in the terminal:'\n )\n", (4030, 4123), True, 'import streamlit as st\n'), ((4115, 4158), 'streamlit.code', 'st.code', (['"""\n\t\t\tstreamlit run main.py\n\t\t"""'], {}), '("""\n\t\t\tstreamlit run main.py\n\t\t""")\n', (4122, 4158), True, 'import streamlit as st\n'), ((4160, 4259), 'streamlit.markdown', 'st.markdown', (['"""3. You should see a Streamlit application running at http://localhost:8501"""'], {}), "(\n '3. You should see a Streamlit application running at http://localhost:8501'\n )\n", (4171, 4259), True, 'import streamlit as st\n'), ((4255, 4332), 'streamlit.markdown', 'st.markdown', (['"""4. Type Ctrl + C in VS Code terminal to stop the Streamlit app"""'], {}), "('4. Type Ctrl + C in VS Code terminal to stop the Streamlit app')\n", (4266, 4332), True, 'import streamlit as st\n'), ((4338, 4374), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (4349, 4374), True, 'import streamlit as st\n'), ((4376, 4399), 'streamlit.write', 'st.write', (['"""Hello World"""'], {}), "('Hello World')\n", (4384, 4399), True, 'import streamlit as st\n'), ((4426, 4452), 'streamlit.subheader', 'st.subheader', (['"""Objectives"""'], {}), "('Objectives')\n", (4438, 4452), True, 'import streamlit as st\n'), ((4454, 4561), 'streamlit.markdown', 'st.markdown', (['"""1. Learn how to use Python and Streamlit library to create an interactive web app."""'], {}), "(\n '1. Learn how to use Python and Streamlit library to create an interactive web app.'\n )\n", (4465, 4561), True, 'import streamlit as st\n'), ((4553, 4683), 'streamlit.markdown', 'st.markdown', (['"""2. Learn how to integrate and use OpenAI\'s API in their streamlit application to create a simple chatbot."""'], {}), '(\n "2. Learn how to integrate and use OpenAI\'s API in their streamlit application to create a simple chatbot."\n )\n', (4564, 4683), True, 'import streamlit as st\n'), ((4675, 4791), 'streamlit.markdown', 'st.markdown', (['"""3. Learn how to apply basic prompt engineering to enhance the interaction with the chatbot."""'], {}), "(\n '3. Learn how to apply basic prompt engineering to enhance the interaction with the chatbot.'\n )\n", (4686, 4791), True, 'import streamlit as st\n'), ((4808, 4831), 'streamlit.subheader', 'st.subheader', (['"""Outline"""'], {}), "('Outline')\n", (4820, 4831), True, 'import streamlit as st\n'), ((4833, 4887), 'streamlit.markdown', 'st.markdown', (['"""Part 0: Workshop introduction and rules"""'], {}), "('Part 0: Workshop introduction and rules')\n", (4844, 4887), True, 'import streamlit as st\n'), ((4889, 4948), 'streamlit.markdown', 'st.markdown', (['"""Part 1: Introduction to Python and Streamlit"""'], {}), "('Part 1: Introduction to Python and Streamlit')\n", (4900, 4948), True, 'import streamlit as st\n'), ((4950, 5002), 'streamlit.markdown', 'st.markdown', (['"""Part 2: Creating a rule-based chatbot"""'], {}), "('Part 2: Creating a rule-based chatbot')\n", (4961, 5002), True, 'import streamlit as st\n'), ((5004, 5064), 'streamlit.markdown', 'st.markdown', (['"""Part 3: Creating a chatbot using OpenAI\'s API"""'], {}), '("Part 3: Creating a chatbot using OpenAI\'s API")\n', (5015, 5064), True, 'import streamlit as st\n'), ((5066, 5135), 'streamlit.markdown', 'st.markdown', (['"""Part 4: Modifying your chatbot with prompt engineering"""'], {}), "('Part 4: Modifying your chatbot with prompt engineering')\n", (5077, 5135), True, 'import streamlit as st\n'), ((5163, 5262), 'streamlit.write', 'st.write', (['"""Do introduce yourself to your teammates:\n"""', '"""1) name\n"""', '"""2) division\n"""', '"""3) role"""'], {}), "('Do introduce yourself to your teammates:\\n', '1) name\\n',\n '2) division\\n', '3) role')\n", (5171, 5262), True, 'import streamlit as st\n'), ((5260, 5333), 'streamlit.write', 'st.write', (['"""Please also share your favourite Star Wars character and why!"""'], {}), "('Please also share your favourite Star Wars character and why!')\n", (5268, 5333), True, 'import streamlit as st\n'), ((5343, 5380), 'PIL.Image.open', 'Image.open', (['"""team_introductions.jpeg"""'], {}), "('team_introductions.jpeg')\n", (5353, 5380), False, 'from PIL import Image\n'), ((5382, 5421), 'streamlit.image', 'st.image', (['image'], {'caption': '"""Hello there!"""'}), "(image, caption='Hello there!')\n", (5390, 5421), True, 'import streamlit as st\n'), ((5446, 5476), 'streamlit.subheader', 'st.subheader', (['"""Workshop Rules"""'], {}), "('Workshop Rules')\n", (5458, 5476), True, 'import streamlit as st\n'), ((5478, 5519), 'streamlit.write', 'st.write', (['"""1. Ask if you have questions."""'], {}), "('1. Ask if you have questions.')\n", (5486, 5519), True, 'import streamlit as st\n'), ((5521, 5583), 'streamlit.write', 'st.write', (['"""2. Be open to different ways to solve the problem."""'], {}), "('2. Be open to different ways to solve the problem.')\n", (5529, 5583), True, 'import streamlit as st\n'), ((5585, 5625), 'streamlit.write', 'st.write', (['"""3. Try. Fail. Learn. Repeat."""'], {}), "('3. Try. Fail. Learn. Repeat.')\n", (5593, 5625), True, 'import streamlit as st\n'), ((5627, 5676), 'streamlit.write', 'st.write', (['"""4. Seek help from other team members."""'], {}), "('4. Seek help from other team members.')\n", (5635, 5676), True, 'import streamlit as st\n'), ((5678, 5738), 'streamlit.write', 'st.write', (['"""5. Collaborate, if possible, for the challenges."""'], {}), "('5. Collaborate, if possible, for the challenges.')\n", (5686, 5738), True, 'import streamlit as st\n'), ((5740, 5815), 'streamlit.write', 'st.write', (['"""6. Approach facilitators if your team cannot solve the problem."""'], {}), "('6. Approach facilitators if your team cannot solve the problem.')\n", (5748, 5815), True, 'import streamlit as st\n'), ((5817, 5868), 'streamlit.write', 'st.write', (['"""7. Toilet break is own-time-own-target."""'], {}), "('7. Toilet break is own-time-own-target.')\n", (5825, 5868), True, 'import streamlit as st\n'), ((5870, 5894), 'streamlit.write', 'st.write', (['"""8. Have fun!"""'], {}), "('8. Have fun!')\n", (5878, 5894), True, 'import streamlit as st\n'), ((5914, 5962), 'streamlit.subheader', 'st.subheader', (['"""Navigating the VS Code interface"""'], {}), "('Navigating the VS Code interface')\n", (5926, 5962), True, 'import streamlit as st\n'), ((5972, 6006), 'PIL.Image.open', 'Image.open', (['"""VSCode_interface.png"""'], {}), "('VSCode_interface.png')\n", (5982, 6006), False, 'from PIL import Image\n'), ((6008, 6052), 'streamlit.image', 'st.image', (['image'], {'caption': '"""VS Code UI layout"""'}), "(image, caption='VS Code UI layout')\n", (6016, 6052), True, 'import streamlit as st\n'), ((6054, 6173), 'streamlit.markdown', 'st.markdown', (['"""**A: Activity Bar: this is where you can see the different activities you can do in VS Code.**"""'], {}), "(\n '**A: Activity Bar: this is where you can see the different activities you can do in VS Code.**'\n )\n", (6065, 6173), True, 'import streamlit as st\n'), ((6165, 6270), 'streamlit.markdown', 'st.markdown', (['"""\tExplorer: this is where you can see all the files and folders in your project."""'], {}), "(\n '\\tExplorer: this is where you can see all the files and folders in your project.'\n )\n", (6176, 6270), True, 'import streamlit as st\n'), ((6261, 6372), 'streamlit.markdown', 'st.markdown', (['"""\tSource Control: this is where you can see the changes you have made to your project."""'], {}), "(\n '\\tSource Control: this is where you can see the changes you have made to your project.'\n )\n", (6272, 6372), True, 'import streamlit as st\n'), ((6363, 6449), 'streamlit.markdown', 'st.markdown', (['"""\tExtensions: this is where you can install extensions to VS Code."""'], {}), "(\n '\\tExtensions: this is where you can install extensions to VS Code.')\n", (6374, 6449), True, 'import streamlit as st\n'), ((6445, 6515), 'streamlit.markdown', 'st.markdown', (['"""\tRun and Debug: this is where you can debug your code."""'], {}), "('\\tRun and Debug: this is where you can debug your code.')\n", (6456, 6515), True, 'import streamlit as st\n'), ((6516, 6620), 'streamlit.markdown', 'st.markdown', (['"""**B: Side Bar: this is where you can see the different views of your project.**"""'], {}), "(\n '**B: Side Bar: this is where you can see the different views of your project.**'\n )\n", (6527, 6620), True, 'import streamlit as st\n'), ((6612, 6720), 'streamlit.markdown', 'st.markdown', (['"""**C: Editor: this is where you can see the code you have written in your project.**"""'], {}), "(\n '**C: Editor: this is where you can see the code you have written in your project.**'\n )\n", (6623, 6720), True, 'import streamlit as st\n'), ((6712, 6830), 'streamlit.markdown', 'st.markdown', (['"""**D: Panel: this is where you can see the different panels you have opened in your project.**"""'], {}), "(\n '**D: Panel: this is where you can see the different panels you have opened in your project.**'\n )\n", (6723, 6830), True, 'import streamlit as st\n'), ((6822, 6900), 'streamlit.markdown', 'st.markdown', (['"""\tTerminal: this is where you can run commands in your project."""'], {}), "('\\tTerminal: this is where you can run commands in your project.')\n", (6833, 6900), True, 'import streamlit as st\n'), ((6901, 6976), 'streamlit.markdown', 'st.markdown', (['"""\tOutput: this is where you can see the output of your code."""'], {}), "('\\tOutput: this is where you can see the output of your code.')\n", (6912, 6976), True, 'import streamlit as st\n'), ((6977, 7054), 'streamlit.markdown', 'st.markdown', (['"""\tProblems: this is where you can see the errors in your code."""'], {}), "('\\tProblems: this is where you can see the errors in your code.')\n", (6988, 7054), True, 'import streamlit as st\n'), ((7055, 7147), 'streamlit.markdown', 'st.markdown', (['"""**E. Status Bar: this is where you can see the status of your project.**"""'], {}), "(\n '**E. Status Bar: this is where you can see the status of your project.**')\n", (7066, 7147), True, 'import streamlit as st\n'), ((7175, 7405), 'streamlit.markdown', 'st.markdown', (['"""Python is very particular about indentation.\nUse the command palette to automatically indent your code.\n\nWindows: Ctrl-Shift-P \nMac: Command-Shift-P\n\nSelect the option to *Convert Indentation to Tabs*"""'], {}), '(\n """Python is very particular about indentation.\nUse the command palette to automatically indent your code.\n\nWindows: Ctrl-Shift-P \nMac: Command-Shift-P\n\nSelect the option to *Convert Indentation to Tabs*"""\n )\n', (7186, 7405), True, 'import streamlit as st\n'), ((7407, 7448), 'PIL.Image.open', 'Image.open', (['"""command_palette_command.png"""'], {}), "('command_palette_command.png')\n", (7417, 7448), False, 'from PIL import Image\n'), ((7450, 7512), 'streamlit.image', 'st.image', (['image'], {'caption': '"""Command Palette auto-indent command"""'}), "(image, caption='Command Palette auto-indent command')\n", (7458, 7512), True, 'import streamlit as st\n'), ((7536, 7641), 'streamlit.write', 'st.write', (['"""This is what we will working towards and building by the end of the workshop today."""'], {}), "(\n 'This is what we will working towards and building by the end of the workshop today.'\n )\n", (7544, 7641), True, 'import streamlit as st\n'), ((7633, 7674), 'streamlit.write', 'st.write', (['"""Do try out the chatbot below!"""'], {}), "('Do try out the chatbot below!')\n", (7641, 7674), True, 'import streamlit as st\n'), ((7676, 7732), 'streamlit.subheader', 'st.subheader', (['"""**:green[Feel the force! Yoda Chatbot]**"""'], {}), "('**:green[Feel the force! Yoda Chatbot]**')\n", (7688, 7732), True, 'import streamlit as st\n'), ((7742, 7764), 'PIL.Image.open', 'Image.open', (['"""yoda.jpg"""'], {}), "('yoda.jpg')\n", (7752, 7764), False, 'from PIL import Image\n'), ((7766, 7820), 'streamlit.image', 'st.image', (['image'], {'caption': '"""Master Yoda at your service"""'}), "(image, caption='Master Yoda at your service')\n", (7774, 7820), True, 'import streamlit as st\n'), ((7822, 7834), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (7832, 7834), True, 'import streamlit as st\n'), ((9208, 9255), 'streamlit.subheader', 'st.subheader', (['"""Useful resources and references"""'], {}), "('Useful resources and references')\n", (9220, 9255), True, 'import streamlit as st\n'), ((9257, 9343), 'streamlit.markdown', 'st.markdown', (['"""1. [Streamlit documentation](https://docs.streamlit.io/en/stable/)"""'], {}), "(\n '1. [Streamlit documentation](https://docs.streamlit.io/en/stable/)')\n", (9268, 9343), True, 'import streamlit as st\n'), ((9340, 9432), 'streamlit.markdown', 'st.markdown', (['"""2. [OpenAI API documentation](https://beta.openai.com/docs/introduction)"""'], {}), "(\n '2. [OpenAI API documentation](https://beta.openai.com/docs/introduction)')\n", (9351, 9432), True, 'import streamlit as st\n'), ((9429, 9506), 'streamlit.markdown', 'st.markdown', (['"""3. [VS Code documentation](https://code.visualstudio.com/docs)"""'], {}), "('3. [VS Code documentation](https://code.visualstudio.com/docs)')\n", (9440, 9506), True, 'import streamlit as st\n'), ((9508, 9576), 'streamlit.markdown', 'st.markdown', (['"""4. [Python documentation](https://docs.python.org/3/)"""'], {}), "('4. [Python documentation](https://docs.python.org/3/)')\n", (9519, 9576), True, 'import streamlit as st\n'), ((9578, 9650), 'streamlit.markdown', 'st.markdown', (['"""5. [Python cheatsheet](https://www.pythoncheatsheet.org/)"""'], {}), "('5. [Python cheatsheet](https://www.pythoncheatsheet.org/)')\n", (9589, 9650), True, 'import streamlit as st\n'), ((9652, 9743), 'streamlit.markdown', 'st.markdown', (['"""6. [Python for beginners](https://www.python.org/about/gettingstarted/)"""'], {}), "(\n '6. [Python for beginners](https://www.python.org/about/gettingstarted/)')\n", (9663, 9743), True, 'import streamlit as st\n'), ((9740, 9851), 'streamlit.markdown', 'st.markdown', (['"""7. [ChatGPT](https://chat.openai.com/) - you can ask ChatGPT to generate code for you!"""'], {}), "(\n '7. [ChatGPT](https://chat.openai.com/) - you can ask ChatGPT to generate code for you!'\n )\n", (9751, 9851), True, 'import streamlit as st\n'), ((9843, 10017), 'streamlit.markdown', 'st.markdown', (['"""**Notes for this workshop course:** \n- you may do a single click to copy all the code \n- challenge code is hidden, click reveal to see the code"""'], {}), '(\n """**Notes for this workshop course:** \n- you may do a single click to copy all the code \n- challenge code is hidden, click reveal to see the code"""\n )\n', (9854, 10017), True, 'import streamlit as st\n'), ((10007, 10237), 'streamlit.markdown', 'st.markdown', (['"""Python is very particular about indentation.\nUse the command palette to automatically indent your code.\n\nWindows: Ctrl-Shift-P \nMac: Command-Shift-P\n\nSelect the option to *Convert Indentation to Tabs*"""'], {}), '(\n """Python is very particular about indentation.\nUse the command palette to automatically indent your code.\n\nWindows: Ctrl-Shift-P \nMac: Command-Shift-P\n\nSelect the option to *Convert Indentation to Tabs*"""\n )\n', (10018, 10237), True, 'import streamlit as st\n'), ((10239, 10280), 'PIL.Image.open', 'Image.open', (['"""command_palette_command.png"""'], {}), "('command_palette_command.png')\n", (10249, 10280), False, 'from PIL import Image\n'), ((10282, 10344), 'streamlit.image', 'st.image', (['image'], {'caption': '"""Command Palette auto-indent command"""'}), "(image, caption='Command Palette auto-indent command')\n", (10290, 10344), True, 'import streamlit as st\n'), ((10367, 10392), 'streamlit.subheader', 'st.subheader', (['"""Streamlit"""'], {}), "('Streamlit')\n", (10379, 10392), True, 'import streamlit as st\n'), ((10394, 10790), 'streamlit.markdown', 'st.markdown', (['"""\n\t\t * an open-source Python library\n\t\t * used extensively for machine learning and data science\n\t\t * helps to create interactive web apps in just a few lines of code\n\t\t * highly flexible and supports complex interactive apps with highly customisable UI\n\t\t * Some real world examples:\n\t\t \t* CherGPT in String\n\t\t \t* Metacog for CotF MOE\n\t\t \t* AILC prototype for MOE\n\t\t """'], {}), '(\n """\n\t\t * an open-source Python library\n\t\t * used extensively for machine learning and data science\n\t\t * helps to create interactive web apps in just a few lines of code\n\t\t * highly flexible and supports complex interactive apps with highly customisable UI\n\t\t * Some real world examples:\n\t\t \t* CherGPT in String\n\t\t \t* Metacog for CotF MOE\n\t\t \t* AILC prototype for MOE\n\t\t """\n )\n', (10405, 10790), True, 'import streamlit as st\n'), ((10820, 10843), 'streamlit.write', 'st.write', (['"""Hello World"""'], {}), "('Hello World')\n", (10828, 10843), True, 'import streamlit as st\n'), ((10910, 10942), 'streamlit.text_input', 'st.text_input', (['"""Enter your name"""'], {}), "('Enter your name')\n", (10923, 10942), True, 'import streamlit as st\n'), ((11001, 11038), 'streamlit.subheader', 'st.subheader', (['"""Exercise 1: Functions"""'], {}), "('Exercise 1: Functions')\n", (11013, 11038), True, 'import streamlit as st\n'), ((11040, 11160), 'streamlit.markdown', 'st.markdown', (['"""In the ***main.py*** file, the code below is already in ***ex1()*** in the ***part1.py*** file."""'], {}), "(\n 'In the ***main.py*** file, the code below is already in ***ex1()*** in the ***part1.py*** file.'\n )\n", (11051, 11160), True, 'import streamlit as st\n'), ((11152, 11237), 'streamlit.write', 'st.write', (['"""The code for *helloworld* is inside what you call a Python function."""'], {}), "('The code for *helloworld* is inside what you call a Python function.'\n )\n", (11160, 11237), True, 'import streamlit as st\n'), ((11234, 11388), 'streamlit.write', 'st.write', (['"""The ***def main()*** function and ***if _ _ name _ _ == \'_ _ main _ _\'*** statement are coding conventions for any Python programme."""'], {}), '(\n "The ***def main()*** function and ***if _ _ name _ _ == \'_ _ main _ _\'*** statement are coding conventions for any Python programme."\n )\n', (11242, 11388), True, 'import streamlit as st\n'), ((11380, 11514), 'streamlit.write', 'st.write', (['"""You need to include an import statement in ***main.py*** to import the ***ex1()*** function from the other file."""'], {}), "(\n 'You need to include an import statement in ***main.py*** to import the ***ex1()*** function from the other file.'\n )\n", (11388, 11514), True, 'import streamlit as st\n'), ((11506, 11544), 'streamlit.code', 'st.code', (['"""\nfrom part1 import ex1\n"""'], {}), '("""\nfrom part1 import ex1\n""")\n', (11513, 11544), True, 'import streamlit as st\n'), ((11546, 11771), 'streamlit.write', 'st.write', (['"""You will need to do the same for all the other exercises and challenges for the rest of the workshop. The code exercises are already in the respective files: ***part1.py, part2.py, part3.py, part4.py***."""'], {}), "(\n 'You will need to do the same for all the other exercises and challenges for the rest of the workshop. The code exercises are already in the respective files: ***part1.py, part2.py, part3.py, part4.py***.'\n )\n", (11554, 11771), True, 'import streamlit as st\n'), ((11763, 11793), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (11774, 11793), True, 'import streamlit as st\n'), ((11795, 12075), 'streamlit.code', 'st.code', (['"""\nimport streamlit as st\n\nfrom part1 import ex1\n\t\t \t \n#Exercise 1: Functions\ndef ex1():\n\tst.write("Hello World")\n\tname = st.text_input("Enter your name")\n\tif name:\n\t\tst.write("Hello " + name)\n\t \ndef main():\n\tex1()\n\t \nif __name__ == "__main__":\n\tmain()\t\t\n\t """'], {}), '(\n """\nimport streamlit as st\n\nfrom part1 import ex1\n\t\t \t \n#Exercise 1: Functions\ndef ex1():\n\tst.write("Hello World")\n\tname = st.text_input("Enter your name")\n\tif name:\n\t\tst.write("Hello " + name)\n\t \ndef main():\n\tex1()\n\t \nif __name__ == "__main__":\n\tmain()\t\t\n\t """\n )\n', (11802, 12075), True, 'import streamlit as st\n'), ((12067, 12137), 'streamlit.markdown', 'st.markdown', (['"""Run the code by typing the following into the terminal:"""'], {}), "('Run the code by typing the following into the terminal:')\n", (12078, 12137), True, 'import streamlit as st\n'), ((12139, 12171), 'streamlit.code', 'st.code', (['"""streamlit run main.py"""'], {}), "('streamlit run main.py')\n", (12146, 12171), True, 'import streamlit as st\n'), ((12173, 12250), 'streamlit.markdown', 'st.markdown', (['"""You should see the following behaviour in your browser window:"""'], {}), "('You should see the following behaviour in your browser window:')\n", (12184, 12250), True, 'import streamlit as st\n'), ((12252, 12288), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (12263, 12288), True, 'import streamlit as st\n'), ((12335, 12367), 'streamlit.text_input', 'st.text_input', (['"""Enter your name"""'], {}), "('Enter your name')\n", (12348, 12367), True, 'import streamlit as st\n'), ((12378, 12431), 'streamlit.selectbox', 'st.selectbox', (['"""State your gender"""', "['Male', 'Female']"], {}), "('State your gender', ['Male', 'Female'])\n", (12390, 12431), True, 'import streamlit as st\n'), ((12439, 12474), 'streamlit.text_input', 'st.text_input', (['"""State your age"""', '(18)'], {}), "('State your age', 18)\n", (12452, 12474), True, 'import streamlit as st\n'), ((12608, 12664), 'streamlit.subheader', 'st.subheader', (['"""Challenge 1: Input, Output and Variables"""'], {}), "('Challenge 1: Input, Output and Variables')\n", (12620, 12664), True, 'import streamlit as st\n'), ((12666, 12780), 'streamlit.write', 'st.write', (['"""Create a new function called ***ch1()*** in ***part1.py*** and call it in the main function."""'], {}), "(\n 'Create a new function called ***ch1()*** in ***part1.py*** and call it in the main function.'\n )\n", (12674, 12780), True, 'import streamlit as st\n'), ((12772, 12876), 'streamlit.write', 'st.write', (['"""Create three variables *name*, *age* and *gender*, and obtain these from the user."""'], {}), "(\n 'Create three variables *name*, *age* and *gender*, and obtain these from the user.'\n )\n", (12780, 12876), True, 'import streamlit as st\n'), ((12868, 12972), 'streamlit.write', 'st.write', (['"""Once the user filled up the input boxes, display back the information to the user."""'], {}), "(\n 'Once the user filled up the input boxes, display back the information to the user.'\n )\n", (12876, 12972), True, 'import streamlit as st\n'), ((12964, 13099), 'streamlit.write', 'st.write', (['"""Code hint: the following piece of code checks if *name* has been filled, and if so, displays it back to the user."""'], {}), "(\n 'Code hint: the following piece of code checks if *name* has been filled, and if so, displays it back to the user.'\n )\n", (12972, 13099), True, 'import streamlit as st\n'), ((13091, 13192), 'streamlit.code', 'st.code', (['"""\nname = st.text_input("Enter your name")\nif name:\n\tst.text(f"Hello {name}")\n"""'], {}), '(\n """\nname = st.text_input("Enter your name")\nif name:\n\tst.text(f"Hello {name}")\n"""\n )\n', (13098, 13192), True, 'import streamlit as st\n'), ((13184, 13214), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (13195, 13214), True, 'import streamlit as st\n'), ((13582, 13618), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (13593, 13618), True, 'import streamlit as st\n'), ((13671, 13724), 'streamlit.selectbox', 'st.selectbox', (['"""State your gender"""', "['Male', 'Female']"], {}), "('State your gender', ['Male', 'Female'])\n", (13683, 13724), True, 'import streamlit as st\n'), ((13788, 13834), 'streamlit.camera_input', 'st.camera_input', (['"""Smile! take a picture here."""'], {}), "('Smile! take a picture here.')\n", (13803, 13834), True, 'import streamlit as st\n'), ((14362, 14418), 'streamlit.subheader', 'st.subheader', (['"""Exercise 2: If-else logical conditionals"""'], {}), "('Exercise 2: If-else logical conditionals')\n", (14374, 14418), True, 'import streamlit as st\n'), ((14420, 14510), 'streamlit.markdown', 'st.markdown', (['"""If-else statements help control the flow and logic of our application."""'], {}), "(\n 'If-else statements help control the flow and logic of our application.')\n", (14431, 14510), True, 'import streamlit as st\n'), ((14507, 14537), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (14518, 14537), True, 'import streamlit as st\n'), ((14539, 15260), 'streamlit.code', 'st.code', (['"""\ndef ex2():\n gender = st.selectbox("State your gender", ["Male", "Female"])\n age = int(st.text_input("State your age", 18))\n photo = st.camera_input("Smile! take a picture here.")\n\n # conditional logic to run different statements\n if age >= 21 and gender == "Male":\n st.write("You are a male adult")\n elif age < 21 and gender == "Male":\n st.write("You are a young boy")\n elif age >= 21 and gender == "Female":\n st.write("You are a female adult")\n elif age < 21 and gender == "Female":\n st.write("You are a young girl")\n\n if photo:\n st.write("Here is your photo: ")\n st.image(photo)\n else:\n st.write("No photo taken")\n"""'], {}), '(\n """\ndef ex2():\n gender = st.selectbox("State your gender", ["Male", "Female"])\n age = int(st.text_input("State your age", 18))\n photo = st.camera_input("Smile! take a picture here.")\n\n # conditional logic to run different statements\n if age >= 21 and gender == "Male":\n st.write("You are a male adult")\n elif age < 21 and gender == "Male":\n st.write("You are a young boy")\n elif age >= 21 and gender == "Female":\n st.write("You are a female adult")\n elif age < 21 and gender == "Female":\n st.write("You are a young girl")\n\n if photo:\n st.write("Here is your photo: ")\n st.image(photo)\n else:\n st.write("No photo taken")\n"""\n )\n', (14546, 15260), True, 'import streamlit as st\n'), ((15252, 15288), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (15263, 15288), True, 'import streamlit as st\n'), ((15580, 15626), 'streamlit.write', 'st.write', (['"""Here is your *person* dictionary: """'], {}), "('Here is your *person* dictionary: ')\n", (15588, 15626), True, 'import streamlit as st\n'), ((15628, 15644), 'streamlit.write', 'st.write', (['person'], {}), '(person)\n', (15636, 15644), True, 'import streamlit as st\n'), ((15683, 15759), 'streamlit.write', 'st.write', (['"""You can also show individual items in the dictionary like this: """'], {}), "('You can also show individual items in the dictionary like this: ')\n", (15691, 15759), True, 'import streamlit as st\n'), ((15883, 15923), 'streamlit.text_input', 'st.text_input', (['"""Enter your name"""', '"""John"""'], {}), "('Enter your name', 'John')\n", (15896, 15923), True, 'import streamlit as st\n'), ((15931, 15966), 'streamlit.text_input', 'st.text_input', (['"""State your age"""', '(30)'], {}), "('State your age', 30)\n", (15944, 15966), True, 'import streamlit as st\n'), ((15977, 16030), 'streamlit.selectbox', 'st.selectbox', (['"""State your gender"""', "['Male', 'Female']"], {}), "('State your gender', ['Male', 'Female'])\n", (15989, 16030), True, 'import streamlit as st\n'), ((16039, 16083), 'streamlit.text_input', 'st.text_input', (['"""State your city"""', '"""New York"""'], {}), "('State your city', 'New York')\n", (16052, 16083), True, 'import streamlit as st\n'), ((16181, 16235), 'streamlit.write', 'st.write', (['"""Here is your updated *person* dictionary: """'], {}), "('Here is your updated *person* dictionary: ')\n", (16189, 16235), True, 'import streamlit as st\n'), ((16237, 16253), 'streamlit.write', 'st.write', (['person'], {}), '(person)\n', (16245, 16253), True, 'import streamlit as st\n'), ((16274, 16317), 'streamlit.subheader', 'st.subheader', (['"""Exercise 3: Data and Loops """'], {}), "('Exercise 3: Data and Loops ')\n", (16286, 16317), True, 'import streamlit as st\n'), ((16319, 16421), 'streamlit.write', 'st.write', (['"""We can store data in a list or dictionary and display the data using a for loop."""'], {}), "(\n 'We can store data in a list or dictionary and display the data using a for loop.'\n )\n", (16327, 16421), True, 'import streamlit as st\n'), ((16413, 16527), 'streamlit.write', 'st.write', (['"""Append the following code to the ***main.py*** file. Refresh the browser to see the changes."""'], {}), "(\n 'Append the following code to the ***main.py*** file. Refresh the browser to see the changes.'\n )\n", (16421, 16527), True, 'import streamlit as st\n'), ((16519, 16588), 'streamlit.write', 'st.write', (['"""You should see output similar to the *Code Output* below."""'], {}), "('You should see output similar to the *Code Output* below.')\n", (16527, 16588), True, 'import streamlit as st\n'), ((16590, 16620), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (16601, 16620), True, 'import streamlit as st\n'), ((16622, 17584), 'streamlit.code', 'st.code', (['"""\n#Data and Loops\ndef ex3():\n\t# Data list\n\tfruits = ["apple", "banana", "orange"]\n\n\t# For loop to show list\n\tfor fruit in fruits:\n\t\tst.write(fruit)\n\n\t# Dictionary\n\tperson = {"name": "John", "age": 30, "city": "New York"}\n\n\t# Print out the items in the dictionary\n\tst.write("Here is your *person* dictionary: ")\n\tst.write(person)\n\n\t# for loop to show dictionary list\n\tst.write("You can also show individual items in the dictionary like this: ")\n\tfor key, value in person.items():\n\t\tst.write(key + ": " + str(value))\n\n\t# get user input to update the dictionary\n\tname = st.text_input("Enter your name", "John")\n\tage = st.text_input("State your age", 30)\n\tgender = st.selectbox("State your gender", ["Male", "Female"])\n\tcity = st.text_input("State your city", "New York")\n\tperson["name"] = name\n\tperson["age"] = age\n\tperson["gender"] = gender\n\tperson["city"] = city\n\t\n\tst.write("Here is your updated *person* dictionary: ")\n\tst.write(person)\n"""'], {}), '(\n """\n#Data and Loops\ndef ex3():\n\t# Data list\n\tfruits = ["apple", "banana", "orange"]\n\n\t# For loop to show list\n\tfor fruit in fruits:\n\t\tst.write(fruit)\n\n\t# Dictionary\n\tperson = {"name": "John", "age": 30, "city": "New York"}\n\n\t# Print out the items in the dictionary\n\tst.write("Here is your *person* dictionary: ")\n\tst.write(person)\n\n\t# for loop to show dictionary list\n\tst.write("You can also show individual items in the dictionary like this: ")\n\tfor key, value in person.items():\n\t\tst.write(key + ": " + str(value))\n\n\t# get user input to update the dictionary\n\tname = st.text_input("Enter your name", "John")\n\tage = st.text_input("State your age", 30)\n\tgender = st.selectbox("State your gender", ["Male", "Female"])\n\tcity = st.text_input("State your city", "New York")\n\tperson["name"] = name\n\tperson["age"] = age\n\tperson["gender"] = gender\n\tperson["city"] = city\n\t\n\tst.write("Here is your updated *person* dictionary: ")\n\tst.write(person)\n"""\n )\n', (16629, 17584), True, 'import streamlit as st\n'), ((17576, 17612), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (17587, 17612), True, 'import streamlit as st\n'), ((18096, 18137), 'streamlit.write', 'st.write', (['"""name: """', 'st.session_state.name'], {}), "('name: ', st.session_state.name)\n", (18104, 18137), True, 'import streamlit as st\n'), ((18139, 18178), 'streamlit.write', 'st.write', (['"""age: """', 'st.session_state.age'], {}), "('age: ', st.session_state.age)\n", (18147, 18178), True, 'import streamlit as st\n'), ((18180, 18225), 'streamlit.write', 'st.write', (['"""gender: """', 'st.session_state.gender'], {}), "('gender: ', st.session_state.gender)\n", (18188, 18225), True, 'import streamlit as st\n'), ((18247, 18288), 'streamlit.subheader', 'st.subheader', (['"""Exercise 4a: Session Data"""'], {}), "('Exercise 4a: Session Data')\n", (18259, 18288), True, 'import streamlit as st\n'), ((18290, 18412), 'streamlit.write', 'st.write', (['"""We can create variables to store data in a user session. Session data persist within a user session."""'], {}), "(\n 'We can create variables to store data in a user session. Session data persist within a user session.'\n )\n", (18298, 18412), True, 'import streamlit as st\n'), ((18405, 18435), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (18416, 18435), True, 'import streamlit as st\n'), ((18437, 19071), 'streamlit.code', 'st.code', (['"""\n# Exercise 4: Session State\ndef ex4a():\n\tst.subheader("Session Data:")\n\tif "session_data" not in st.session_state:\n\t\tst.session_state.session_data = ["alpha", "omega"]\n\t\n\tif "name" not in st.session_state:\n\t\tst.session_state.name = ""\n\t\n\tif "age" not in st.session_state:\n\t\tst.session_state.age = ""\n\n\tif "gender" not in st.session_state:\n\t\tst.session_state.gender = ""\n\t\n\t# For loop to show list\n\tfor data in st.session_state.session_data:\n\t\tst.write("session_data: ", data)\n\n\tst.write("name: ", st.session_state.name)\n\tst.write("age: ", st.session_state.age)\n\tst.write("gender: ", st.session_state.gender)\n"""'], {}), '(\n """\n# Exercise 4: Session State\ndef ex4a():\n\tst.subheader("Session Data:")\n\tif "session_data" not in st.session_state:\n\t\tst.session_state.session_data = ["alpha", "omega"]\n\t\n\tif "name" not in st.session_state:\n\t\tst.session_state.name = ""\n\t\n\tif "age" not in st.session_state:\n\t\tst.session_state.age = ""\n\n\tif "gender" not in st.session_state:\n\t\tst.session_state.gender = ""\n\t\n\t# For loop to show list\n\tfor data in st.session_state.session_data:\n\t\tst.write("session_data: ", data)\n\n\tst.write("name: ", st.session_state.name)\n\tst.write("age: ", st.session_state.age)\n\tst.write("gender: ", st.session_state.gender)\n"""\n )\n', (18444, 19071), True, 'import streamlit as st\n'), ((19067, 19103), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (19078, 19103), True, 'import streamlit as st\n'), ((19183, 19215), 'streamlit.text_input', 'st.text_input', (['"""Enter your name"""'], {}), "('Enter your name')\n", (19196, 19215), True, 'import streamlit as st\n'), ((19228, 19259), 'streamlit.text_input', 'st.text_input', (['"""State your age"""'], {}), "('State your age')\n", (19241, 19259), True, 'import streamlit as st\n'), ((19275, 19332), 'streamlit.selectbox', 'st.selectbox', (['"""State your gender"""', "['', 'Male', 'Female']"], {}), "('State your gender', ['', 'Male', 'Female'])\n", (19287, 19332), True, 'import streamlit as st\n'), ((19650, 19707), 'streamlit.subheader', 'st.subheader', (['"""Exercise 4b: Session Data with User Input"""'], {}), "('Exercise 4b: Session Data with User Input')\n", (19662, 19707), True, 'import streamlit as st\n'), ((19709, 19787), 'streamlit.write', 'st.write', (['"""Lets now get input from the user and store it in the session data."""'], {}), "('Lets now get input from the user and store it in the session data.')\n", (19717, 19787), True, 'import streamlit as st\n'), ((19789, 19878), 'streamlit.write', 'st.write', (['"""Now run *ex4a()* again to check the session data. Note that it persists."""'], {}), "(\n 'Now run *ex4a()* again to check the session data. Note that it persists.')\n", (19797, 19878), True, 'import streamlit as st\n'), ((19876, 19906), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (19887, 19906), True, 'import streamlit as st\n'), ((19908, 20427), 'streamlit.code', 'st.code', (['"""\ndef ex4b():\n\tst.subheader("Session Data:")\n\tuserName = st.text_input("Enter your name")\n\tuserAge = st.text_input("State your age")\n\tuserGender = st.selectbox("State your gender", ["", "Male", "Female"])\n\n\tif userName:\n\t\tst.session_state.name = userName\n\t\tst.write("name: ", st.session_state.name)\n\tif userAge:\n\t\tst.session_state.age = int(userAge)\n\t\tst.write("age: ", st.session_state.age)\n\tif userGender:\n\t\tst.session_state.gender = userGender\n\t\tst.write("gender: ", st.session_state.gender)\n"""'], {}), '(\n """\ndef ex4b():\n\tst.subheader("Session Data:")\n\tuserName = st.text_input("Enter your name")\n\tuserAge = st.text_input("State your age")\n\tuserGender = st.selectbox("State your gender", ["", "Male", "Female"])\n\n\tif userName:\n\t\tst.session_state.name = userName\n\t\tst.write("name: ", st.session_state.name)\n\tif userAge:\n\t\tst.session_state.age = int(userAge)\n\t\tst.write("age: ", st.session_state.age)\n\tif userGender:\n\t\tst.session_state.gender = userGender\n\t\tst.write("gender: ", st.session_state.gender)\n"""\n )\n', (19915, 20427), True, 'import streamlit as st\n'), ((20419, 20455), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (20430, 20455), True, 'import streamlit as st\n'), ((20931, 20986), 'streamlit.write', 'st.write', (['"""session_state.name: """', 'st.session_state.name'], {}), "('session_state.name: ', st.session_state.name)\n", (20939, 20986), True, 'import streamlit as st\n'), ((20988, 21041), 'streamlit.write', 'st.write', (['"""session_state.age: """', 'st.session_state.age'], {}), "('session_state.age: ', st.session_state.age)\n", (20996, 21041), True, 'import streamlit as st\n'), ((21043, 21102), 'streamlit.write', 'st.write', (['"""session_state.gender: """', 'st.session_state.gender'], {}), "('session_state.gender: ', st.session_state.gender)\n", (21051, 21102), True, 'import streamlit as st\n'), ((21104, 21181), 'streamlit.write', 'st.write', (['"""session_state.prompt_template: """', 'st.session_state.prompt_template'], {}), "('session_state.prompt_template: ', st.session_state.prompt_template)\n", (21112, 21181), True, 'import streamlit as st\n'), ((21202, 21243), 'streamlit.subheader', 'st.subheader', (['"""Challenge 4: Session Data"""'], {}), "('Challenge 4: Session Data')\n", (21214, 21243), True, 'import streamlit as st\n'), ((21245, 22105), 'streamlit.markdown', 'st.markdown', (['"""\n\t\t Add a new function called ***ch4()*** to the ***part1.py*** file and call it in the main function.\n\n\t\t In *ch4()*, modify the code in Exercise 4b to include the following:\n\t\t * Create session data for ***name***, ***age*** and ***gender***\n\t\t * Create session data for ***prompt_template*** with the following value:\n\t\t\t "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"\n\t\t * Include this code in ***main()*** as well, because we need the session data for later exercises. Omit the ***st.write*** functions, since we do not want to see this output every time we run ***main()***. \n\n\t\t Hint:\n\t\t * In ***ch4()***, to check that the session data is created, you can print out the session data using ***st.write()***:\n\t\t """'], {}), '(\n """\n\t\t Add a new function called ***ch4()*** to the ***part1.py*** file and call it in the main function.\n\n\t\t In *ch4()*, modify the code in Exercise 4b to include the following:\n\t\t * Create session data for ***name***, ***age*** and ***gender***\n\t\t * Create session data for ***prompt_template*** with the following value:\n\t\t\t "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"\n\t\t * Include this code in ***main()*** as well, because we need the session data for later exercises. Omit the ***st.write*** functions, since we do not want to see this output every time we run ***main()***. \n\n\t\t Hint:\n\t\t * In ***ch4()***, to check that the session data is created, you can print out the session data using ***st.write()***:\n\t\t """\n )\n', (21256, 22105), True, 'import streamlit as st\n'), ((22099, 22129), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (22110, 22129), True, 'import streamlit as st\n'), ((23448, 23484), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (23459, 23484), True, 'import streamlit as st\n'), ((23524, 23552), 'streamlit.title', 'st.title', (['"""My first chatbot"""'], {}), "('My first chatbot')\n", (23532, 23552), True, 'import streamlit as st\n'), ((23640, 23670), 'streamlit.chat_input', 'st.chat_input', (['"""Say something"""'], {}), "('Say something')\n", (23653, 23670), True, 'import streamlit as st\n'), ((23997, 24046), 'streamlit.subheader', 'st.subheader', (['"""Exercise 5: Elements of a chatbot"""'], {}), "('Exercise 5: Elements of a chatbot')\n", (24009, 24046), True, 'import streamlit as st\n'), ((24048, 24122), 'streamlit.write', 'st.write', (['"""We will start creating a user interface for our first chatbot."""'], {}), "('We will start creating a user interface for our first chatbot.')\n", (24056, 24122), True, 'import streamlit as st\n'), ((24124, 24199), 'streamlit.write', 'st.write', (['"""Call the following code from ***part1.py*** in your **main()**."""'], {}), "('Call the following code from ***part1.py*** in your **main()**.')\n", (24132, 24199), True, 'import streamlit as st\n'), ((24201, 24273), 'streamlit.write', 'st.write', (['"""You should see the output below when you run your programme."""'], {}), "('You should see the output below when you run your programme.')\n", (24209, 24273), True, 'import streamlit as st\n'), ((24275, 24305), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (24286, 24305), True, 'import streamlit as st\n'), ((24307, 24823), 'streamlit.code', 'st.code', (['"""\n#Exercise 5 : Chatbot UI\ndef ex5():\n\tst.title("My first chatbot")\n\n\tif "store_msg" not in st.session_state:\n\t\tst.session_state.store_msg = []\n\n\tprompt = st.chat_input("Say something")\n\tif prompt:\n\t\tst.write(f"User has sent the following prompt: {prompt}")\n\t\tst.session_state.store_msg.append(prompt)\n\t\tfor message in st.session_state.store_msg:\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.write(message)\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tst.write("Hello human, what can I do for you?")\n"""'], {}), '(\n """\n#Exercise 5 : Chatbot UI\ndef ex5():\n\tst.title("My first chatbot")\n\n\tif "store_msg" not in st.session_state:\n\t\tst.session_state.store_msg = []\n\n\tprompt = st.chat_input("Say something")\n\tif prompt:\n\t\tst.write(f"User has sent the following prompt: {prompt}")\n\t\tst.session_state.store_msg.append(prompt)\n\t\tfor message in st.session_state.store_msg:\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.write(message)\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tst.write("Hello human, what can I do for you?")\n"""\n )\n', (24314, 24823), True, 'import streamlit as st\n'), ((24815, 24851), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (24826, 24851), True, 'import streamlit as st\n'), ((24891, 24918), 'streamlit.markdown', 'st.markdown', (['"""**Echo Bot**"""'], {}), "('**Echo Bot**')\n", (24902, 24918), True, 'import streamlit as st\n'), ((25757, 25815), 'streamlit.subheader', 'st.subheader', (['"""Exercise 6: Building a simple echo chatbot"""'], {}), "('Exercise 6: Building a simple echo chatbot')\n", (25769, 25815), True, 'import streamlit as st\n'), ((25817, 25869), 'streamlit.write', 'st.write', (['"""We will now build a simple echo chatbot."""'], {}), "('We will now build a simple echo chatbot.')\n", (25825, 25869), True, 'import streamlit as st\n'), ((25871, 25946), 'streamlit.write', 'st.write', (['"""Call the following code from **part1.py** in your ***main()***."""'], {}), "('Call the following code from **part1.py** in your ***main()***.')\n", (25879, 25946), True, 'import streamlit as st\n'), ((25948, 26020), 'streamlit.write', 'st.write', (['"""You should see the output below when you run your programme."""'], {}), "('You should see the output below when you run your programme.')\n", (25956, 26020), True, 'import streamlit as st\n'), ((26022, 26052), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (26033, 26052), True, 'import streamlit as st\n'), ((26054, 26968), 'streamlit.code', 'st.code', (['"""\n#Exercise 6 : Rule-based Echo Chatbot \ndef ex6():\n\tst.title("Echo Bot")\n\n\t# Initialize chat history\n\tif "messages" not in st.session_state:\n\t\tst.session_state.messages = []\n\n\t# Display chat messages from history on app rerun\n\tfor message in st.session_state.messages:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\n\t# React to user input\n\tif prompt := st.chat_input("What is up?"):\n\t\t# Display user message in chat message container\n\t\tst.chat_message("user").markdown(prompt)\n\t\t# Add user message to chat history\n\t\tst.session_state.messages.append({"role": "user", "content": prompt})\n\n\t\tresponse = f"Echo: {prompt}"\n\t\t# Display assistant response in chat message container\n\t\twith st.chat_message("assistant"):\n\t\t\tst.markdown(response)\n\t\t# Add assistant response to chat history\n\t\tst.session_state.messages.append({"role": "assistant", "content": response})\n"""'], {}), '(\n """\n#Exercise 6 : Rule-based Echo Chatbot \ndef ex6():\n\tst.title("Echo Bot")\n\n\t# Initialize chat history\n\tif "messages" not in st.session_state:\n\t\tst.session_state.messages = []\n\n\t# Display chat messages from history on app rerun\n\tfor message in st.session_state.messages:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\n\t# React to user input\n\tif prompt := st.chat_input("What is up?"):\n\t\t# Display user message in chat message container\n\t\tst.chat_message("user").markdown(prompt)\n\t\t# Add user message to chat history\n\t\tst.session_state.messages.append({"role": "user", "content": prompt})\n\n\t\tresponse = f"Echo: {prompt}"\n\t\t# Display assistant response in chat message container\n\t\twith st.chat_message("assistant"):\n\t\t\tst.markdown(response)\n\t\t# Add assistant response to chat history\n\t\tst.session_state.messages.append({"role": "assistant", "content": response})\n"""\n )\n', (26061, 26968), True, 'import streamlit as st\n'), ((26960, 26996), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (26971, 26996), True, 'import streamlit as st\n'), ((27036, 27069), 'streamlit.markdown', 'st.markdown', (['"""**Rule Based Bot**"""'], {}), "('**Rule Based Bot**')\n", (27047, 27069), True, 'import streamlit as st\n'), ((28014, 28062), 'streamlit.subheader', 'st.subheader', (['"""Challenge 6: Rule based chatbot """'], {}), "('Challenge 6: Rule based chatbot ')\n", (28026, 28062), True, 'import streamlit as st\n'), ((28064, 28709), 'streamlit.markdown', 'st.markdown', (['"""\n\t\t Create a new function called ***ch6()*** in **part1.py** and modify the ***ex6()*** function to create the following rule based chatbot:\n\n\t\t * Human : “Hello”, Assistant: “Hi there what can I do for you”\n\n\t\t * Human : “What is your name?”, Assistant: “My name is EAI , an electronic artificial being”\n\t\n\t\t * Human : “How old are you?”, Assistant: “Today is my birthday!”\n\n\t\t For other queries, it will reply “I am sorry, I am unable to help you with your query”\n\n\t\t Use *if / elif / else* statements to create the chatbot behaviour logic.\n \n\t\t You should see the output below when you run your programme.\n\n\t\t """'], {}), '(\n """\n\t\t Create a new function called ***ch6()*** in **part1.py** and modify the ***ex6()*** function to create the following rule based chatbot:\n\n\t\t * Human : “Hello”, Assistant: “Hi there what can I do for you”\n\n\t\t * Human : “What is your name?”, Assistant: “My name is EAI , an electronic artificial being”\n\t\n\t\t * Human : “How old are you?”, Assistant: “Today is my birthday!”\n\n\t\t For other queries, it will reply “I am sorry, I am unable to help you with your query”\n\n\t\t Use *if / elif / else* statements to create the chatbot behaviour logic.\n \n\t\t You should see the output below when you run your programme.\n\n\t\t """\n )\n', (28075, 28709), True, 'import streamlit as st\n'), ((28708, 28738), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (28719, 28738), True, 'import streamlit as st\n'), ((29805, 29841), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (29816, 29841), True, 'import streamlit as st\n'), ((29888, 29930), 'streamlit.subheader', 'st.subheader', (['"""Exercise 7: Secrets- Shhh """'], {}), "('Exercise 7: Secrets- Shhh ')\n", (29900, 29930), True, 'import streamlit as st\n'), ((29932, 30000), 'streamlit.write', 'st.write', (['"""In this exercise, we will learn how to hide your API key"""'], {}), "('In this exercise, we will learn how to hide your API key')\n", (29940, 30000), True, 'import streamlit as st\n'), ((30002, 30297), 'streamlit.markdown', 'st.markdown', (['"""\n\tIn your working directory (chatbot), create a directory called **.streamlit**\n\n\tNote the *dot* in front of the directory\n\n\tIn this folder, create a file called **secrets.toml**\n\n\tGet an API key from your OpenAI account and type the following in **secrets.toml**:\n\t"""'], {}), '(\n """\n\tIn your working directory (chatbot), create a directory called **.streamlit**\n\n\tNote the *dot* in front of the directory\n\n\tIn this folder, create a file called **secrets.toml**\n\n\tGet an API key from your OpenAI account and type the following in **secrets.toml**:\n\t"""\n )\n', (30013, 30297), True, 'import streamlit as st\n'), ((30292, 30322), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (30303, 30322), True, 'import streamlit as st\n'), ((30324, 30365), 'streamlit.code', 'st.code', (['"""\n\topenapi_key = "xxxxxx"\n\t"""'], {}), '("""\n\topenapi_key = "xxxxxx"\n\t""")\n', (30331, 30365), True, 'import streamlit as st\n'), ((30367, 30483), 'streamlit.write', 'st.write', (['"""Include the following global variables in your ***main.py*** file under the import statements:"""'], {}), "(\n 'Include the following global variables in your ***main.py*** file under the import statements:'\n )\n", (30375, 30483), True, 'import streamlit as st\n'), ((30475, 30601), 'streamlit.code', 'st.code', (['"""\nos.environ["OPENAI_API_KEY"] = st.secrets["openapi_key"]\nopenai.api_key = st.secrets["openapi_key"]\n"""'], {}), '(\n """\nos.environ["OPENAI_API_KEY"] = st.secrets["openapi_key"]\nopenai.api_key = st.secrets["openapi_key"]\n"""\n )\n', (30482, 30601), True, 'import streamlit as st\n'), ((30593, 30656), 'streamlit.write', 'st.write', (['"""Create a .gitignore file and add .streamlit into it"""'], {}), "('Create a .gitignore file and add .streamlit into it')\n", (30601, 30656), True, 'import streamlit as st\n'), ((30740, 30760), 'streamlit.title', 'st.title', (['"""Api Call"""'], {}), "('Api Call')\n", (30748, 30760), True, 'import streamlit as st\n'), ((30798, 31018), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'MODEL', 'messages': "[{'role': 'system', 'content': 'You are a helpful assistant.'}, {'role':\n 'user', 'content': 'Tell me about Singapore in the 1970s in 50 words.'}]", 'temperature': '(0)'}), "(model=MODEL, messages=[{'role': 'system',\n 'content': 'You are a helpful assistant.'}, {'role': 'user', 'content':\n 'Tell me about Singapore in the 1970s in 50 words.'}], temperature=0)\n", (30826, 31018), False, 'import openai\n'), ((31033, 31077), 'streamlit.markdown', 'st.markdown', (['"""**This is the raw response:**"""'], {}), "('**This is the raw response:**')\n", (31044, 31077), True, 'import streamlit as st\n'), ((31080, 31098), 'streamlit.write', 'st.write', (['response'], {}), '(response)\n', (31088, 31098), True, 'import streamlit as st\n'), ((31100, 31150), 'streamlit.markdown', 'st.markdown', (['"""**This is the extracted response:**"""'], {}), "('**This is the extracted response:**')\n", (31111, 31150), True, 'import streamlit as st\n'), ((31260, 31297), 'streamlit.markdown', 'st.markdown', (['"""**Total tokens used:**"""'], {}), "('**Total tokens used:**')\n", (31271, 31297), True, 'import streamlit as st\n'), ((31299, 31310), 'streamlit.write', 'st.write', (['s'], {}), '(s)\n', (31307, 31310), True, 'import streamlit as st\n'), ((31331, 31385), 'streamlit.subheader', 'st.subheader', (['"""Exercise 8: Calling the OpenAI LLM API"""'], {}), "('Exercise 8: Calling the OpenAI LLM API')\n", (31343, 31385), True, 'import streamlit as st\n'), ((31387, 31461), 'streamlit.write', 'st.write', (['"""In this exercise, we will learn how to call the OpenAI LLM API"""'], {}), "('In this exercise, we will learn how to call the OpenAI LLM API')\n", (31395, 31461), True, 'import streamlit as st\n'), ((31463, 31534), 'streamlit.write', 'st.write', (['"""Note that there is a new import statement **import openai**"""'], {}), "('Note that there is a new import statement **import openai**')\n", (31471, 31534), True, 'import streamlit as st\n'), ((31536, 31674), 'streamlit.markdown', 'st.markdown', (['"""\n\t\t Call the following code in your **main()** and run it.\n\n\t\t You should see the output as shown below.\n\n\t\t """'], {}), '(\n """\n\t\t Call the following code in your **main()** and run it.\n\n\t\t You should see the output as shown below.\n\n\t\t """\n )\n', (31547, 31674), True, 'import streamlit as st\n'), ((31668, 31698), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (31679, 31698), True, 'import streamlit as st\n'), ((31700, 32363), 'streamlit.code', 'st.code', (['"""\nimport openai\n\t \n#Exercise 8 : Using the OpenAI API\ndef ex8():\n\tst.title("Api Call")\n\tMODEL = "gpt-3.5-turbo"\n\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": "You are a helpful assistant."},\n\t\t\t{"role": "user", "content": "Tell me about Singapore in the 1970s in 50 words."},\n\t\t],\n\t\ttemperature=0,\n\t)\n\n\tst.markdown("**This is the raw response:**") \n\tst.write(response)\n\tst.markdown("**This is the extracted response:**")\n\tst.write(response["choices"][0]["message"]["content"].strip())\n\ts = str(response["usage"]["total_tokens"])\n\tst.markdown("**Total tokens used:**")\n\tst.write(s)\n"""'], {}), '(\n """\nimport openai\n\t \n#Exercise 8 : Using the OpenAI API\ndef ex8():\n\tst.title("Api Call")\n\tMODEL = "gpt-3.5-turbo"\n\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": "You are a helpful assistant."},\n\t\t\t{"role": "user", "content": "Tell me about Singapore in the 1970s in 50 words."},\n\t\t],\n\t\ttemperature=0,\n\t)\n\n\tst.markdown("**This is the raw response:**") \n\tst.write(response)\n\tst.markdown("**This is the extracted response:**")\n\tst.write(response["choices"][0]["message"]["content"].strip())\n\ts = str(response["usage"]["total_tokens"])\n\tst.markdown("**Total tokens used:**")\n\tst.write(s)\n"""\n )\n', (31707, 32363), True, 'import streamlit as st\n'), ((32355, 32391), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (32366, 32391), True, 'import streamlit as st\n'), ((32485, 32660), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'MODEL', 'messages': "[{'role': 'system', 'content': 'You are a helpful assistant.'}, {'role':\n 'user', 'content': prompt}]", 'temperature': '(0)'}), "(model=MODEL, messages=[{'role': 'system',\n 'content': 'You are a helpful assistant.'}, {'role': 'user', 'content':\n prompt}], temperature=0)\n", (32513, 32660), False, 'import openai\n'), ((32755, 32831), 'streamlit.subheader', 'st.subheader', (['"""Challenge 8: Incorporate your LLM API call into your chatbot"""'], {}), "('Challenge 8: Incorporate your LLM API call into your chatbot')\n", (32767, 32831), True, 'import streamlit as st\n'), ((32833, 32954), 'streamlit.write', 'st.write', (['"""In this challenge, we will incorporate the LLM API call into our previous rule-based *Echo* chatbot"""'], {}), "(\n 'In this challenge, we will incorporate the LLM API call into our previous rule-based *Echo* chatbot'\n )\n", (32841, 32954), True, 'import streamlit as st\n'), ((32946, 33545), 'streamlit.markdown', 'st.markdown', (['"""\n**Step1**\n\nCreate a new function **ch8()** in ***part1.py*** and copy the code from **ex6()** into it. Recall that **ex6()** shows the chat history and gets a chat input from the user, and echoes the user input back to the user. \n\n**Step 2**\n\nNext, copy the code from **ex8** into a new function named **chat_completion()**. Recall that **ex8()** is about making an API call.\n\nNow, instead of echoing the user\'s input in **ex6()**, we will call the LLM API to generate a response. In particular, we are replacing this line of code with the response from the API call:\n\n"""'], {}), '(\n """\n**Step1**\n\nCreate a new function **ch8()** in ***part1.py*** and copy the code from **ex6()** into it. Recall that **ex6()** shows the chat history and gets a chat input from the user, and echoes the user input back to the user. \n\n**Step 2**\n\nNext, copy the code from **ex8** into a new function named **chat_completion()**. Recall that **ex8()** is about making an API call.\n\nNow, instead of echoing the user\'s input in **ex6()**, we will call the LLM API to generate a response. In particular, we are replacing this line of code with the response from the API call:\n\n"""\n )\n', (32957, 33545), True, 'import streamlit as st\n'), ((33542, 33588), 'streamlit.code', 'st.code', (['"""\nresponse = f"Echo: {prompt}\\"\n"""'], {}), '("""\nresponse = f"Echo: {prompt}\\"\n""")\n', (33549, 33588), True, 'import streamlit as st\n'), ((33589, 33994), 'streamlit.markdown', 'st.markdown', (['"""\n**Step 3**\n\nIn **chat_completion()**, what we will do is to replace the previous *Tell me the history ..."* prompt from **ex8()** with the current user\'s input.\n\nIn order to do so, in **ch8()**, use the following code to call **chat_completion()**.\n\nWhat we are doing now is to pass the prompt from the user to the API call instead of hard-coding the prompt as in **ex8()**.\n"""'], {}), '(\n """\n**Step 3**\n\nIn **chat_completion()**, what we will do is to replace the previous *Tell me the history ..."* prompt from **ex8()** with the current user\'s input.\n\nIn order to do so, in **ch8()**, use the following code to call **chat_completion()**.\n\nWhat we are doing now is to pass the prompt from the user to the API call instead of hard-coding the prompt as in **ex8()**.\n"""\n )\n', (33600, 33994), True, 'import streamlit as st\n'), ((33990, 34193), 'streamlit.code', 'st.code', (['"""\n\t if prompt := st.chat.input("What\'s up?"):\n\t \t#display user messgae in chat message container\n\t \treply = chat_completion(prompt) \n\t \tst.chat_message("user").markdown(prompt)\n\t\t"""'], {}), '(\n """\n\t if prompt := st.chat.input("What\'s up?"):\n\t \t#display user messgae in chat message container\n\t \treply = chat_completion(prompt) \n\t \tst.chat_message("user").markdown(prompt)\n\t\t"""\n )\n', (33997, 34193), True, 'import streamlit as st\n'), ((34185, 34243), 'streamlit.write', 'st.write', (['"""You should see the code output as shown below."""'], {}), "('You should see the code output as shown below.')\n", (34193, 34243), True, 'import streamlit as st\n'), ((34245, 34275), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (34256, 34275), True, 'import streamlit as st\n'), ((35559, 35595), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (35570, 35595), True, 'import streamlit as st\n'), ((35597, 35623), 'streamlit.title', 'st.title', (['"""My LLM Chatbot"""'], {}), "('My LLM Chatbot')\n", (35605, 35623), True, 'import streamlit as st\n'), ((36510, 36697), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'MODEL', 'messages': "[{'role': 'system', 'content': 'You are a helpful assistant'}, {'role':\n 'user', 'content': prompt}]", 'temperature': '(0)', 'stream': '(True)'}), "(model=MODEL, messages=[{'role': 'system',\n 'content': 'You are a helpful assistant'}, {'role': 'user', 'content':\n prompt}], temperature=0, stream=True)\n", (36538, 36697), False, 'import openai\n'), ((37746, 37833), 'streamlit.subheader', 'st.subheader', (['"""Exercise 9: Building a ChatGPT-like clone with streaming responses"""'], {}), "(\n 'Exercise 9: Building a ChatGPT-like clone with streaming responses')\n", (37758, 37833), True, 'import streamlit as st\n'), ((37830, 37966), 'streamlit.write', 'st.write', (['"""Now, we will incorporate a streaming response from the LLM API into our chatbot to mimic the behaviour of ChatGPT."""'], {}), "(\n 'Now, we will incorporate a streaming response from the LLM API into our chatbot to mimic the behaviour of ChatGPT.'\n )\n", (37838, 37966), True, 'import streamlit as st\n'), ((37958, 38029), 'streamlit.write', 'st.write', (['"""Copy and run the code below to see the streaming responses."""'], {}), "('Copy and run the code below to see the streaming responses.')\n", (37966, 38029), True, 'import streamlit as st\n'), ((38031, 38061), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (38042, 38061), True, 'import streamlit as st\n'), ((38063, 39535), 'streamlit.code', 'st.code', (['"""\n# Exercise 9 : Using the OpenAI API with streaming option\ndef chat_completion_stream(prompt):\n\topenai.api_key = st.secrets["openapi_key"]\n\tMODEL = "gpt-3.5-turbo"\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": "You are a helpful assistant"},\n\t\t\t{"role": "user", "content": prompt},\n\t\t],\n\t\ttemperature=0, # temperature\n\t\tstream=True, # stream option\n\t)\n\treturn response\n\n# integration API call into streamlit chat components\ndef ex9_basebot():\n\t# Initialize chat history\n\tif "chat_msg" not in st.session_state:\n\t\tst.session_state.chat_msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.chat_msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t# set user prompt in chat history\n\t\t\tst.session_state.chat_msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t# streaming function\n\t\t\t\tfor response in chat_completion_stream(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.chat_msg.append(\n\t\t\t\t{"role": "assistant", "content": full_response}\n\t\t\t)\n\n\texcept Exception as e:\n\t\tst.error(e)\n"""'], {}), '(\n """\n# Exercise 9 : Using the OpenAI API with streaming option\ndef chat_completion_stream(prompt):\n\topenai.api_key = st.secrets["openapi_key"]\n\tMODEL = "gpt-3.5-turbo"\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": "You are a helpful assistant"},\n\t\t\t{"role": "user", "content": prompt},\n\t\t],\n\t\ttemperature=0, # temperature\n\t\tstream=True, # stream option\n\t)\n\treturn response\n\n# integration API call into streamlit chat components\ndef ex9_basebot():\n\t# Initialize chat history\n\tif "chat_msg" not in st.session_state:\n\t\tst.session_state.chat_msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.chat_msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t# set user prompt in chat history\n\t\t\tst.session_state.chat_msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t# streaming function\n\t\t\t\tfor response in chat_completion_stream(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.chat_msg.append(\n\t\t\t\t{"role": "assistant", "content": full_response}\n\t\t\t)\n\n\texcept Exception as e:\n\t\tst.error(e)\n"""\n )\n', (38070, 39535), True, 'import streamlit as st\n'), ((39527, 39563), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (39538, 39563), True, 'import streamlit as st\n'), ((39712, 39937), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'MODEL', 'messages': "[{'role': 'system', 'content': st.session_state.prompt_template}, {'role':\n 'user', 'content': 'Tell me about Singapore in the 1970s in 50 words'}]", 'temperature': '(0)'}), "(model=MODEL, messages=[{'role': 'system',\n 'content': st.session_state.prompt_template}, {'role': 'user',\n 'content': 'Tell me about Singapore in the 1970s in 50 words'}],\n temperature=0)\n", (39740, 39937), False, 'import openai\n'), ((39962, 39994), 'streamlit.markdown', 'st.markdown', (['"""**LLM Response:**"""'], {}), "('**LLM Response:**')\n", (39973, 39994), True, 'import streamlit as st\n'), ((40060, 40092), 'streamlit.markdown', 'st.markdown', (['"""**Total tokens:**"""'], {}), "('**Total tokens:**')\n", (40071, 40092), True, 'import streamlit as st\n'), ((40164, 40217), 'streamlit.subheader', 'st.subheader', (['"""Exercise 10: Basic Prompt Engineering"""'], {}), "('Exercise 10: Basic Prompt Engineering')\n", (40176, 40217), True, 'import streamlit as st\n'), ((40219, 40583), 'streamlit.markdown', 'st.markdown', (['"""\n\t\t Now, we are going to create a chatbot with a personality by using a default prompt for our chatbot. \n\n\t\t This is the default prompt that will be used for every conversation.\n\n\t\t Let\'s make it a chatbot that speaks like Yoda from Star Wars.\n\n\t\t We will use the ***prompt_template*** that is already in our ***main()*** for this.\n\t\t """'], {}), '(\n """\n\t\t Now, we are going to create a chatbot with a personality by using a default prompt for our chatbot. \n\n\t\t This is the default prompt that will be used for every conversation.\n\n\t\t Let\'s make it a chatbot that speaks like Yoda from Star Wars.\n\n\t\t We will use the ***prompt_template*** that is already in our ***main()*** for this.\n\t\t """\n )\n', (40230, 40583), True, 'import streamlit as st\n'), ((40578, 40847), 'streamlit.code', 'st.code', (['"""\nif "prompt_template" not in st.session_state:\n\tst.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"\n\t"""'], {}), '(\n """\nif "prompt_template" not in st.session_state:\n\tst.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"\n\t"""\n )\n', (40585, 40847), True, 'import streamlit as st\n'), ((40839, 41063), 'streamlit.markdown', 'st.markdown', (['"""\n\t\t Run the code below. You should get the same chatbot behaviour as the code output below.\n\n\t\t Try varying the temperature setting (0.0 to 1.0) to see how it affects the chatbot\'s response.\n\n\t\t """'], {}), '(\n """\n\t\t Run the code below. You should get the same chatbot behaviour as the code output below.\n\n\t\t Try varying the temperature setting (0.0 to 1.0) to see how it affects the chatbot\'s response.\n\n\t\t """\n )\n', (40850, 41063), True, 'import streamlit as st\n'), ((41057, 41087), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (41068, 41087), True, 'import streamlit as st\n'), ((41089, 41700), 'streamlit.code', 'st.code', (['"""\n# Exercise 10: Basic prompt engineering\ndef ex10_basebot():\n\t#prompt_template in session state already set in main()\n\tMODEL = "gpt-3.5-turbo"\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": st.session_state.prompt_template},\n\t\t\t{\n\t\t\t\t"role": "user",\n\t\t\t\t"content": "Tell me about Singapore in the 1970s in 50 words",\n\t\t\t},\n\t\t],\n\t\ttemperature=0,\n\t)\n\tst.markdown("**LLM Response:**")\n\tst.write(response["choices"][0]["message"]["content"].strip())\n\tst.markdown("**Total tokens:**")\n\tst.write(str(response["usage"]["total_tokens"]))\n"""'], {}), '(\n """\n# Exercise 10: Basic prompt engineering\ndef ex10_basebot():\n\t#prompt_template in session state already set in main()\n\tMODEL = "gpt-3.5-turbo"\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": st.session_state.prompt_template},\n\t\t\t{\n\t\t\t\t"role": "user",\n\t\t\t\t"content": "Tell me about Singapore in the 1970s in 50 words",\n\t\t\t},\n\t\t],\n\t\ttemperature=0,\n\t)\n\tst.markdown("**LLM Response:**")\n\tst.write(response["choices"][0]["message"]["content"].strip())\n\tst.markdown("**Total tokens:**")\n\tst.write(str(response["usage"]["total_tokens"]))\n"""\n )\n', (41096, 41700), True, 'import streamlit as st\n'), ((41692, 41728), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (41703, 41728), True, 'import streamlit as st\n'), ((41988, 42178), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'MODEL', 'messages': "[{'role': 'system', 'content': st.session_state.prompt_template}, {'role':\n 'user', 'content': prompt}]", 'temperature': '(0)', 'stream': '(True)'}), "(model=MODEL, messages=[{'role': 'system',\n 'content': st.session_state.prompt_template}, {'role': 'user',\n 'content': prompt}], temperature=0, stream=True)\n", (42016, 42178), False, 'import openai\n'), ((43282, 43348), 'streamlit.subheader', 'st.subheader', (['"""Challenge 10: Make your bot like someone you know!"""'], {}), "('Challenge 10: Make your bot like someone you know!')\n", (43294, 43348), True, 'import streamlit as st\n'), ((43350, 43445), 'streamlit.write', 'st.write', (['"""Modify the ***prompt_template*** in your ***main()*** to your own liking."""'], {}), "(\n 'Modify the ***prompt_template*** in your ***main()*** to your own liking.'\n )\n", (43358, 43445), True, 'import streamlit as st\n'), ((43437, 43464), 'streamlit.write', 'st.write', (['"""Be imaginative!"""'], {}), "('Be imaginative!')\n", (43445, 43464), True, 'import streamlit as st\n'), ((43466, 43657), 'streamlit.write', 'st.write', (['"""Now, in new function called **chat_completion_stream_prompt()**, we are going to modify the earlier **streaming chat_completion** function to accept a user prompt input."""'], {}), "(\n 'Now, in new function called **chat_completion_stream_prompt()**, we are going to modify the earlier **streaming chat_completion** function to accept a user prompt input.'\n )\n", (43474, 43657), True, 'import streamlit as st\n'), ((43649, 43797), 'streamlit.write', 'st.write', (['"""You will need to pass in a new input variable called **prompt** and replace the user content with the new **prompt** variable."""'], {}), "(\n 'You will need to pass in a new input variable called **prompt** and replace the user content with the new **prompt** variable.'\n )\n", (43657, 43797), True, 'import streamlit as st\n'), ((43789, 43874), 'streamlit.write', 'st.write', (['"""Replace the system prompt with **st.session_state.prompt_template**."""'], {}), "('Replace the system prompt with **st.session_state.prompt_template**.'\n )\n", (43797, 43874), True, 'import streamlit as st\n'), ((43871, 44037), 'streamlit.write', 'st.write', (['"""Before calling **chat_completion_stream_prompt()**, get a new prompt from the user like this to update the **st.session_state.prompt_template**:"""'], {}), "(\n 'Before calling **chat_completion_stream_prompt()**, get a new prompt from the user like this to update the **st.session_state.prompt_template**:'\n )\n", (43879, 44037), True, 'import streamlit as st\n'), ((44029, 44295), 'streamlit.code', 'st.code', (['"""\nif my_prompt_template := st.text_input("Enter a system prompt template. E.g. Speak like Yoda from Star Wars."):\n\tst.session_state.prompt_template = my_prompt_template\n\tst.write("new prompt template set! ", st.session_state.prompt_template)\n"""'], {}), '(\n """\nif my_prompt_template := st.text_input("Enter a system prompt template. E.g. Speak like Yoda from Star Wars."):\n\tst.session_state.prompt_template = my_prompt_template\n\tst.write("new prompt template set! ", st.session_state.prompt_template)\n"""\n )\n', (44036, 44295), True, 'import streamlit as st\n'), ((44287, 44317), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (44298, 44317), True, 'import streamlit as st\n'), ((45887, 45923), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (45898, 45923), True, 'import streamlit as st\n'), ((45925, 45979), 'streamlit.title', 'st.title', (['"""ChatGPT-like clone with Prompt Engineering"""'], {}), "('ChatGPT-like clone with Prompt Engineering')\n", (45933, 45979), True, 'import streamlit as st\n'), ((46111, 46266), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['subject', 'topic']", 'template': '"""Design a lesson plan on {subject} on the topic of {topic} for primary 1 students"""'}), "(input_variables=['subject', 'topic'], template=\n 'Design a lesson plan on {subject} on the topic of {topic} for primary 1 students'\n )\n", (46125, 46266), False, 'from langchain.prompts import PromptTemplate\n'), ((46323, 46378), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0.9)'}), "(model_name='gpt-3.5-turbo', temperature=0.9)\n", (46333, 46378), False, 'from langchain.chat_models import ChatOpenAI\n'), ((46457, 46489), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (46465, 46489), False, 'from langchain.chains import LLMChain\n'), ((46494, 46519), 'streamlit.button', 'st.button', (['"""Run my chain"""'], {}), "('Run my chain')\n", (46503, 46519), True, 'import streamlit as st\n'), ((46793, 46853), 'streamlit.subheader', 'st.subheader', (['"""Exercise 11a: Prompt Template with LangChain"""'], {}), "('Exercise 11a: Prompt Template with LangChain')\n", (46805, 46853), True, 'import streamlit as st\n'), ((46855, 46956), 'streamlit.write', 'st.write', (['"""LangChain helps you to create a more complext prompt template for your chatbot."""'], {}), "(\n 'LangChain helps you to create a more complext prompt template for your chatbot.'\n )\n", (46863, 46956), True, 'import streamlit as st\n'), ((46949, 46979), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (46960, 46979), True, 'import streamlit as st\n'), ((46981, 47789), 'streamlit.code', 'st.code', (['"""\n#https://python.langchain.com/docs/modules/chains/\ndef ex11a(): # change in ex11a\n\t# langchain prompt template\n\tprompt = PromptTemplate(\n\t\tinput_variables=["subject", "topic"],\n\t\ttemplate=""\\"Design a lesson plan on {subject} on the topic of {topic} for primary 1 students""\\",\n\t)\n\n\t# openai_api_key = st.secrets["openapi_key"]\n\tllm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.9)\n\n\t# creating a LLM chain with the langchain call and prompt template\n\tchain = LLMChain(llm=llm, prompt=prompt)\n\tif st.button("Run my chain"):\n\t\tinput_prompt = prompt.format(subject="English", topic="Verbs")\n\t\t# Showing what is sent to LLM Chain\n\t\tst.write("Input prompt: ", input_prompt)\n\t\t# Showing the output from LLM Chain\n\t\tst.write(chain.run({"subject": "English", "topic": "Verbs"}))\n"""'], {}), '(\n """\n#https://python.langchain.com/docs/modules/chains/\ndef ex11a(): # change in ex11a\n\t# langchain prompt template\n\tprompt = PromptTemplate(\n\t\tinput_variables=["subject", "topic"],\n\t\ttemplate=""\\"Design a lesson plan on {subject} on the topic of {topic} for primary 1 students""\\",\n\t)\n\n\t# openai_api_key = st.secrets["openapi_key"]\n\tllm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.9)\n\n\t# creating a LLM chain with the langchain call and prompt template\n\tchain = LLMChain(llm=llm, prompt=prompt)\n\tif st.button("Run my chain"):\n\t\tinput_prompt = prompt.format(subject="English", topic="Verbs")\n\t\t# Showing what is sent to LLM Chain\n\t\tst.write("Input prompt: ", input_prompt)\n\t\t# Showing the output from LLM Chain\n\t\tst.write(chain.run({"subject": "English", "topic": "Verbs"}))\n"""\n )\n', (46988, 47789), True, 'import streamlit as st\n'), ((47779, 47815), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (47790, 47815), True, 'import streamlit as st\n'), ((48484, 48823), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['occupation', 'topic', 'age']", 'template': '"""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""'}), "(input_variables=['occupation', 'topic', 'age'], template=\n 'Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up'\n )\n", (48498, 48823), False, 'from langchain.prompts import PromptTemplate\n'), ((48879, 48934), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0.9)'}), "(model_name='gpt-3.5-turbo', temperature=0.9)\n", (48889, 48934), False, 'from langchain.chat_models import ChatOpenAI\n'), ((49018, 49059), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt_template'}), '(llm=llm, prompt=prompt_template)\n', (49026, 49059), False, 'from langchain.chains import LLMChain\n'), ((49203, 49231), 'streamlit.subheader', 'st.subheader', (['"""Exercise 11b"""'], {}), "('Exercise 11b')\n", (49215, 49231), True, 'import streamlit as st\n'), ((49233, 49329), 'streamlit.write', 'st.write', (['"""Now, we will create a chatbot with a prompt template that is more complex."""'], {}), "(\n 'Now, we will create a chatbot with a prompt template that is more complex.'\n )\n", (49241, 49329), True, 'import streamlit as st\n'), ((49321, 49443), 'streamlit.write', 'st.write', (['"""We will use the ***prompt_inputs_form()*** function to get the user\'s input for the prompt template."""'], {}), '(\n "We will use the ***prompt_inputs_form()*** function to get the user\'s input for the prompt template."\n )\n', (49329, 49443), True, 'import streamlit as st\n'), ((49435, 49495), 'streamlit.write', 'st.write', (['"""Run the code below to see the chatbot in action."""'], {}), "('Run the code below to see the chatbot in action.')\n", (49443, 49495), True, 'import streamlit as st\n'), ((49498, 49528), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (49509, 49528), True, 'import streamlit as st\n'), ((49530, 50886), 'streamlit.code', 'st.code', (['"""\ndef prompt_inputs_form(): # Using st.form, create the starting prompt to your prompt template, this is an expert on a topic that is talking to a user of a certain age\n\t# langchain prompt template\n\twith st.form("Prompt Template"):\n\t\toccupation = st.text_input("Enter the occupation:")\n\t\ttopic = st.text_input("Enter the topic:")\n\t\tage = st.text_input("Enter the age:")\n\n\t\t# Every form must have a submit button.\n\t\tsubmitted = st.form_submit_button("Submit")\n\t# return a dictionary of the values\n\tif submitted:\n\t\treturn {"occupation": occupation, "topic": topic, "age": age}\n\ndef ex11b():\n\t# create your template\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\t# create a langchain function call to openai\n\tllm = ChatOpenAI(\n\t\tmodel_name="gpt-3.5-turbo",\n\t\ttemperature=0.9,\n\t)\n\t# create a LLM chain with the langchain call and prompt template\n\tchain = LLMChain(llm=llm, prompt=prompt_template)\n\t# call the prompt_inputs_form()\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tst.write(chain.run(dict_inputs))\n"""'], {}), '(\n """\ndef prompt_inputs_form(): # Using st.form, create the starting prompt to your prompt template, this is an expert on a topic that is talking to a user of a certain age\n\t# langchain prompt template\n\twith st.form("Prompt Template"):\n\t\toccupation = st.text_input("Enter the occupation:")\n\t\ttopic = st.text_input("Enter the topic:")\n\t\tage = st.text_input("Enter the age:")\n\n\t\t# Every form must have a submit button.\n\t\tsubmitted = st.form_submit_button("Submit")\n\t# return a dictionary of the values\n\tif submitted:\n\t\treturn {"occupation": occupation, "topic": topic, "age": age}\n\ndef ex11b():\n\t# create your template\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\t# create a langchain function call to openai\n\tllm = ChatOpenAI(\n\t\tmodel_name="gpt-3.5-turbo",\n\t\ttemperature=0.9,\n\t)\n\t# create a LLM chain with the langchain call and prompt template\n\tchain = LLMChain(llm=llm, prompt=prompt_template)\n\t# call the prompt_inputs_form()\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tst.write(chain.run(dict_inputs))\n"""\n )\n', (49537, 50886), True, 'import streamlit as st\n'), ((50878, 50914), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (50889, 50914), True, 'import streamlit as st\n'), ((51092, 51431), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['occupation', 'topic', 'age']", 'template': '"""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""'}), "(input_variables=['occupation', 'topic', 'age'], template=\n 'Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up'\n )\n", (51106, 51431), False, 'from langchain.prompts import PromptTemplate\n'), ((51870, 51930), 'streamlit.subheader', 'st.subheader', (['"""Challenge 11: Prompt Template with LangChain"""'], {}), "('Challenge 11: Prompt Template with LangChain')\n", (51882, 51930), True, 'import streamlit as st\n'), ((51932, 52041), 'streamlit.write', 'st.write', (['"""Now, let\'s incorporate the prompt template into our chatbot from the previous exercise."""'], {}), '(\n "Now, let\'s incorporate the prompt template into our chatbot from the previous exercise."\n )\n', (51940, 52041), True, 'import streamlit as st\n'), ((52033, 52155), 'streamlit.write', 'st.write', (['"""We will use the ***prompt_inputs_form()*** function to get the user\'s input for the prompt template."""'], {}), '(\n "We will use the ***prompt_inputs_form()*** function to get the user\'s input for the prompt template."\n )\n', (52041, 52155), True, 'import streamlit as st\n'), ((52147, 52302), 'streamlit.write', 'st.write', (['"""You can use the ***ch10*** function from the previous exercise to do the llm api call with the updated session_state.prompt_template."""'], {}), "(\n 'You can use the ***ch10*** function from the previous exercise to do the llm api call with the updated session_state.prompt_template.'\n )\n", (52155, 52302), True, 'import streamlit as st\n'), ((52294, 52461), 'streamlit.write', 'st.write', (['"""Ignore the text input field that asks for a system prompt template from ch10(), since we will be using the prompt template from the user\'s input."""'], {}), '(\n "Ignore the text input field that asks for a system prompt template from ch10(), since we will be using the prompt template from the user\'s input."\n )\n', (52302, 52461), True, 'import streamlit as st\n'), ((52453, 52609), 'streamlit.write', 'st.write', (['"""As you interact with the chatbot, observe that the prompt template is updated with the latest user input as seen from the code output."""'], {}), "(\n 'As you interact with the chatbot, observe that the prompt template is updated with the latest user input as seen from the code output.'\n )\n", (52461, 52609), True, 'import streamlit as st\n'), ((52602, 52632), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (52613, 52632), True, 'import streamlit as st\n'), ((53603, 53639), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (53614, 53639), True, 'import streamlit as st\n'), ((53691, 53726), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'k': '(3)'}), '(k=3)\n', (53721, 53726), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((53934, 53991), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'k': '(3)', 'return_messages': '(True)'}), '(k=3, return_messages=True)\n', (53964, 53991), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((54207, 54255), 'streamlit.subheader', 'st.subheader', (['"""Exercise 12: Chatbot with memory"""'], {}), "('Exercise 12: Chatbot with memory')\n", (54219, 54255), True, 'import streamlit as st\n'), ((54257, 54311), 'streamlit.write', 'st.write', (['"""Now, we will create a chatbot with memory."""'], {}), "('Now, we will create a chatbot with memory.')\n", (54265, 54311), True, 'import streamlit as st\n'), ((54313, 54430), 'streamlit.write', 'st.write', (['"""You can determine the number of previous messages to remember by setting the ***k*** parameter."""'], {}), "(\n 'You can determine the number of previous messages to remember by setting the ***k*** parameter.'\n )\n", (54321, 54430), True, 'import streamlit as st\n'), ((54423, 54453), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (54434, 54453), True, 'import streamlit as st\n'), ((54455, 54998), 'streamlit.code', 'st.code', (['"""\ndef ex12():\n\tmemory = ConversationBufferWindowMemory(k=3)\n\tmemory.save_context({"input": "hi"}, {"output": "whats up?"})\n\tmemory.save_context({"input": "not much"}, {"output": "what can I help you with?"})\n\n\tst.write(memory.load_memory_variables({}))\n \n\tmemory = ConversationBufferWindowMemory( k=3, return_messages=True)\n\tmemory.save_context({"input": "hi"}, {"output": "whats up?"})\n\tmemory.save_context({"input": "not much"}, {"output": "what can I help you with?"})\n\n\tst.write(memory.load_memory_variables({}))\n"""'], {}), '(\n """\ndef ex12():\n\tmemory = ConversationBufferWindowMemory(k=3)\n\tmemory.save_context({"input": "hi"}, {"output": "whats up?"})\n\tmemory.save_context({"input": "not much"}, {"output": "what can I help you with?"})\n\n\tst.write(memory.load_memory_variables({}))\n \n\tmemory = ConversationBufferWindowMemory( k=3, return_messages=True)\n\tmemory.save_context({"input": "hi"}, {"output": "whats up?"})\n\tmemory.save_context({"input": "not much"}, {"output": "what can I help you with?"})\n\n\tst.write(memory.load_memory_variables({}))\n"""\n )\n', (54462, 54998), True, 'import streamlit as st\n'), ((54992, 55028), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (55003, 55028), True, 'import streamlit as st\n'), ((55122, 55471), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['occupation', 'topic', 'age']", 'template': '"""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""'}), '(input_variables=[\'occupation\', \'topic\', \'age\'], template=\n """Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""\n )\n', (55136, 55471), False, 'from langchain.prompts import PromptTemplate\n'), ((55725, 55765), 'streamlit.write', 'st.write', (['"""input prompt: """', 'input_prompt'], {}), "('input prompt: ', input_prompt)\n", (55733, 55765), True, 'import streamlit as st\n'), ((56030, 56079), 'streamlit.session_state.memory.load_memory_variables', 'st.session_state.memory.load_memory_variables', (['{}'], {}), '({})\n', (56075, 56079), True, 'import streamlit as st\n'), ((56081, 56119), 'streamlit.write', 'st.write', (['"""Memory Data: """', 'memory_data'], {}), "('Memory Data: ', memory_data)\n", (56089, 56119), True, 'import streamlit as st\n'), ((56284, 56350), 'streamlit.write', 'st.write', (['"""New prompt template:"""', 'st.session_state.prompt_template'], {}), "('New prompt template:', st.session_state.prompt_template)\n", (56292, 56350), True, 'import streamlit as st\n'), ((57422, 57471), 'streamlit.subheader', 'st.subheader', (['"""Challenge 12: Chatbot with memory"""'], {}), "('Challenge 12: Chatbot with memory')\n", (57434, 57471), True, 'import streamlit as st\n'), ((57473, 57568), 'streamlit.write', 'st.write', (['"""Now, let\'s incorporate the memory into the session state prompt template."""'], {}), '(\n "Now, let\'s incorporate the memory into the session state prompt template."\n )\n', (57481, 57568), True, 'import streamlit as st\n'), ((57560, 57694), 'streamlit.write', 'st.write', (['"""The chatbot should remember the previous user input and use it as the prompt template for the next conversation."""'], {}), "(\n 'The chatbot should remember the previous user input and use it as the prompt template for the next conversation.'\n )\n", (57568, 57694), True, 'import streamlit as st\n'), ((57686, 57788), 'streamlit.write', 'st.write', (['"""Start with the following code and modify ex12() to create a chatbot with memory."""'], {}), "(\n 'Start with the following code and modify ex12() to create a chatbot with memory.'\n )\n", (57694, 57788), True, 'import streamlit as st\n'), ((57780, 57846), 'streamlit.write', 'st.write', (['"""Get the *{input_prompt}* using *prompt_inputs_form()*."""'], {}), "('Get the *{input_prompt}* using *prompt_inputs_form()*.')\n", (57788, 57846), True, 'import streamlit as st\n'), ((57848, 58018), 'streamlit.write', 'st.write', (['"""As you interact with the chatbot, observe that the memory is updated with the latest k number of user input and output as seen from the code output."""'], {}), "(\n 'As you interact with the chatbot, observe that the memory is updated with the latest k number of user input and output as seen from the code output.'\n )\n", (57856, 58018), True, 'import streamlit as st\n'), ((58010, 58040), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (58021, 58040), True, 'import streamlit as st\n'), ((58042, 58532), 'streamlit.code', 'st.code', (['"""\nif "memory" not in st.session_state:\n\tst.session_state.memory = ConversationBufferWindowMemory(k=5)\n\n\t#step 1 save the memory from your chatbot \n\t#step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) \n\tmemory_data = st.session_state.memory.load_memory_variables({})\n\tst.write(memory_data)\n\tst.session_state.prompt_template = f""\\"{input_prompt}\n\nBelow is the conversation history between the AI and Users so far\n\n{memory_data}""\\"\n"""'], {}), '(\n """\nif "memory" not in st.session_state:\n\tst.session_state.memory = ConversationBufferWindowMemory(k=5)\n\n\t#step 1 save the memory from your chatbot \n\t#step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) \n\tmemory_data = st.session_state.memory.load_memory_variables({})\n\tst.write(memory_data)\n\tst.session_state.prompt_template = f""\\"{input_prompt}\n\nBelow is the conversation history between the AI and Users so far\n\n{memory_data}""\\"\n"""\n )\n', (58049, 58532), True, 'import streamlit as st\n'), ((58526, 58556), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (58537, 58556), True, 'import streamlit as st\n'), ((60957, 60993), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (60968, 60993), True, 'import streamlit as st\n'), ((61152, 61184), 'streamlit.subheader', 'st.subheader', (['"""Upload your docs"""'], {}), "('Upload your docs')\n", (61164, 61184), True, 'import streamlit as st\n'), ((61251, 61313), 'streamlit.file_uploader', 'st.file_uploader', (['"""Choose a file"""'], {'type': "['docx', 'txt', 'pdf']"}), "('Choose a file', type=['docx', 'txt', 'pdf'])\n", (61267, 61313), True, 'import streamlit as st\n'), ((62066, 62084), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (62082, 62084), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((62091, 62125), 'lancedb.connect', 'lancedb.connect', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (62106, 62125), False, 'import lancedb\n'), ((62967, 63017), 'streamlit.subheader', 'st.subheader', (['"""Exercise 13: Create a vector store"""'], {}), "('Exercise 13: Create a vector store')\n", (62979, 63017), True, 'import streamlit as st\n'), ((63019, 63095), 'streamlit.write', 'st.write', (['"""Now, we will create a vector store to store the user\'s document."""'], {}), '("Now, we will create a vector store to store the user\'s document.")\n', (63027, 63095), True, 'import streamlit as st\n'), ((63097, 63208), 'streamlit.write', 'st.write', (['"""This process uses OpenAI to generate embeddings and LanceDB for storing these embeddings."""'], {}), "(\n 'This process uses OpenAI to generate embeddings and LanceDB for storing these embeddings.'\n )\n", (63105, 63208), True, 'import streamlit as st\n'), ((63200, 63251), 'streamlit.write', 'st.write', (['"""For now, this only works for pdf files."""'], {}), "('For now, this only works for pdf files.')\n", (63208, 63251), True, 'import streamlit as st\n'), ((63253, 63354), 'streamlit.write', 'st.write', (['"""You may need to run the following commands in terminal to install new libaries:"""'], {}), "(\n 'You may need to run the following commands in terminal to install new libaries:'\n )\n", (63261, 63354), True, 'import streamlit as st\n'), ((63346, 63383), 'streamlit.code', 'st.code', (['"""\npip install tiktoken\n"""'], {}), '("""\npip install tiktoken\n""")\n', (63353, 63383), True, 'import streamlit as st\n'), ((63385, 63415), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (63396, 63415), True, 'import streamlit as st\n'), ((63417, 65367), 'streamlit.code', 'st.code', (['"""\n#exercise 13 - loading\ndef upload_file_streamlit():\n\tdef get_file_extension(file_name):\n\t\treturn os.path.splitext(file_name)[1]\n\n\tst.subheader("Upload your docs")\n\n\t# Streamlit file uploader to accept file input\n\tuploaded_file = st.file_uploader("Choose a file", type=["docx", "txt", "pdf"])\n\n\tif uploaded_file:\n\t\t# Reading file content\n\t\tfile_content = uploaded_file.read()\n\n\t\t# Determine the suffix based on uploaded file\'s name\n\t\tfile_suffix = get_file_extension(uploaded_file.name)\n\n\t\t# Saving the uploaded file temporarily to process it\n\t\twith tempfile.NamedTemporaryFile(delete=False, suffix=file_suffix) as temp_file:\n\t\t\ttemp_file.write(file_content)\n\t\t\ttemp_file.flush() # Ensure the data is written to the file\n\t\t\ttemp_file_path = temp_file.name\n\t\treturn temp_file_path\n\t\n#exercise 13 - split and chunk, embeddings and storing in vectorstores for reference\ndef vectorstore_creator():\n\t# WORKING_DIRECTORY set above in the main.py\n\t# Process the temporary file using UnstructuredFileLoader (or any other method you need)\n\tembeddings = OpenAIEmbeddings()\n\tdb = lancedb.connect(WORKING_DIRECTORY)\n\ttable = db.create_table(\n\t\t"my_table",\n\t\tdata=[\n\t\t\t{\n\t\t\t\t"vector": embeddings.embed_query("Query unsuccessful"),\n\t\t\t\t"text": "Query unsuccessful",\n\t\t\t\t"id": "1",\n\t\t\t}\n\t\t],\n\t\tmode="overwrite",\n\t)\n\t# st.write(temp_file_path)\n\ttemp_file_path = upload_file_streamlit()\n\tif temp_file_path:\n\t\tloader = PyPDFLoader(temp_file_path)\n\t\tdocuments = loader.load_and_split()\n\t\tdb = LanceDB.from_documents(documents, embeddings, connection=table)\n\t\treturn db\n\ndef ex13_vectorstore_creator():\n\tif "vectorstore" not in st.session_state:\n\t\tst.session_state.vectorstore = False\n\tdb = vectorstore_creator()\n\tst.session_state.vectorstore = db\n\tif st.session_state.vectorstore:\n\t\tquery = st.text_input("Enter a query")\n\t\tif query:\n\t\t\tst.session_state.vectorstore = db\n\t\t\tdocs = db.similarity_search(query)\n\t\t\tst.write(docs[0].page_content)\n"""'], {}), '(\n """\n#exercise 13 - loading\ndef upload_file_streamlit():\n\tdef get_file_extension(file_name):\n\t\treturn os.path.splitext(file_name)[1]\n\n\tst.subheader("Upload your docs")\n\n\t# Streamlit file uploader to accept file input\n\tuploaded_file = st.file_uploader("Choose a file", type=["docx", "txt", "pdf"])\n\n\tif uploaded_file:\n\t\t# Reading file content\n\t\tfile_content = uploaded_file.read()\n\n\t\t# Determine the suffix based on uploaded file\'s name\n\t\tfile_suffix = get_file_extension(uploaded_file.name)\n\n\t\t# Saving the uploaded file temporarily to process it\n\t\twith tempfile.NamedTemporaryFile(delete=False, suffix=file_suffix) as temp_file:\n\t\t\ttemp_file.write(file_content)\n\t\t\ttemp_file.flush() # Ensure the data is written to the file\n\t\t\ttemp_file_path = temp_file.name\n\t\treturn temp_file_path\n\t\n#exercise 13 - split and chunk, embeddings and storing in vectorstores for reference\ndef vectorstore_creator():\n\t# WORKING_DIRECTORY set above in the main.py\n\t# Process the temporary file using UnstructuredFileLoader (or any other method you need)\n\tembeddings = OpenAIEmbeddings()\n\tdb = lancedb.connect(WORKING_DIRECTORY)\n\ttable = db.create_table(\n\t\t"my_table",\n\t\tdata=[\n\t\t\t{\n\t\t\t\t"vector": embeddings.embed_query("Query unsuccessful"),\n\t\t\t\t"text": "Query unsuccessful",\n\t\t\t\t"id": "1",\n\t\t\t}\n\t\t],\n\t\tmode="overwrite",\n\t)\n\t# st.write(temp_file_path)\n\ttemp_file_path = upload_file_streamlit()\n\tif temp_file_path:\n\t\tloader = PyPDFLoader(temp_file_path)\n\t\tdocuments = loader.load_and_split()\n\t\tdb = LanceDB.from_documents(documents, embeddings, connection=table)\n\t\treturn db\n\ndef ex13_vectorstore_creator():\n\tif "vectorstore" not in st.session_state:\n\t\tst.session_state.vectorstore = False\n\tdb = vectorstore_creator()\n\tst.session_state.vectorstore = db\n\tif st.session_state.vectorstore:\n\t\tquery = st.text_input("Enter a query")\n\t\tif query:\n\t\t\tst.session_state.vectorstore = db\n\t\t\tdocs = db.similarity_search(query)\n\t\t\tst.write(docs[0].page_content)\n"""\n )\n', (63424, 65367), True, 'import streamlit as st\n'), ((65364, 65400), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (65375, 65400), True, 'import streamlit as st\n'), ((65621, 65970), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['occupation', 'topic', 'age']", 'template': '"""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""'}), '(input_variables=[\'occupation\', \'topic\', \'age\'], template=\n """Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""\n )\n', (65635, 65970), False, 'from langchain.prompts import PromptTemplate\n'), ((66589, 66638), 'streamlit.session_state.memory.load_memory_variables', 'st.session_state.memory.load_memory_variables', (['{}'], {}), '({})\n', (66634, 66638), True, 'import streamlit as st\n'), ((66640, 66661), 'streamlit.write', 'st.write', (['memory_data'], {}), '(memory_data)\n', (66648, 66661), True, 'import streamlit as st\n'), ((66825, 66892), 'streamlit.write', 'st.write', (['"""new prompt template: """', 'st.session_state.prompt_template'], {}), "('new prompt template: ', st.session_state.prompt_template)\n", (66833, 66892), True, 'import streamlit as st\n'), ((68569, 68613), 'streamlit.subheader', 'st.subheader', (['"""Exercise 14: Semantic search"""'], {}), "('Exercise 14: Semantic search')\n", (68581, 68613), True, 'import streamlit as st\n'), ((68615, 68719), 'streamlit.write', 'st.write', (['"""In this exercise. we will do a semantic search on the vector store in our chatbot."""'], {}), "(\n 'In this exercise. we will do a semantic search on the vector store in our chatbot.'\n )\n", (68623, 68719), True, 'import streamlit as st\n'), ((68711, 68823), 'streamlit.write', 'st.write', (['"""At the same time, the chatbot is able to remember its conversation history to some extent."""'], {}), "(\n 'At the same time, the chatbot is able to remember its conversation history to some extent.'\n )\n", (68719, 68823), True, 'import streamlit as st\n'), ((68815, 68988), 'streamlit.write', 'st.write', (['"""This code integrates advanced features like semantic search and context-aware prompts to provide a more engaging and helpful conversational experience."""'], {}), "(\n 'This code integrates advanced features like semantic search and context-aware prompts to provide a more engaging and helpful conversational experience.'\n )\n", (68823, 68988), True, 'import streamlit as st\n'), ((68980, 69049), 'streamlit.write', 'st.write', (['"""Copy and run the code below to see the chatbot in action."""'], {}), "('Copy and run the code below to see the chatbot in action.')\n", (68988, 69049), True, 'import streamlit as st\n'), ((69052, 69082), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (69063, 69082), True, 'import streamlit as st\n'), ((69084, 72216), 'streamlit.code', 'st.code', (['"""\n# save the vectorstore in st.session_state\n# add semantic search prompt into memory prompt\n# integrate back into your chatbot\ndef ex14_basebot():\n\t# Prompt_template form from ex11\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tinput_prompt = prompt_template.format(\n\t\t\toccupation=dict_inputs["occupation"],\n\t\t\ttopic=dict_inputs["topic"],\n\t\t\tage=dict_inputs["age"],\n\t\t)\n\t\tst.session_state.input_prompt = input_prompt\n\n\tif "input_prompt" not in st.session_state:\n\t\tst.session_state.input_prompt = "Speak like Yoda from Star Wars"\n\n\tif "memory" not in st.session_state:\n\t\tst.session_state.memory = ConversationBufferWindowMemory(k=5)\n\n\t# step 1 save the memory from your chatbot\n\t# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint\n\tmemory_data = st.session_state.memory.load_memory_variables({})\n\tst.write(memory_data)\n\tst.session_state.prompt_template = f""\\"\n\t\t{st.session_state.input_prompt}\n\n\t\tThis is the last conversation history:\n\t\t{memory_data}""\\"\n\tst.write("new prompt template: ", st.session_state.prompt_template)\n\n\tst.session_state.vectorstore = vectorstore_creator()\n\n\t# Initialize chat history\n\tif "msg" not in st.session_state:\n\t\tst.session_state.msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t# query information\n\t\t\tif st.session_state.vectorstore:\n\t\t\t\tdocs = st.session_state.vectorstore.similarity_search(prompt)\n\t\t\t\tdocs = docs[0].page_content\n\t\t\t\t# add your query prompt\n\t\t\t\tvs_prompt = f""\\"\n\t\t\t\t\tYou should reference this search result to help your answer,\n\t\t\t\t\t{docs}\n\t\t\t\t\tif the search result does not anwer the query, please say you are unable to answer, do not make up an answer""\\"\n\t\t\telse:\n\t\t\t\tvs_prompt = ""\n\t\t\t# add query prompt to your memory prompt and send it to LLM\n\t\t\tst.session_state.prompt_template = (\n\t\t\t\tst.session_state.prompt_template + vs_prompt\n\t\t\t)\n\t\t\t# set user prompt in chat history\n\t\t\tst.session_state.msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t# streaming function\n\t\t\t\tfor response in chat_completion_stream_prompt(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.msg.append({"role": "assistant", "content": full_response})\n\t\t\tst.session_state.memory.save_context(\n\t\t\t\t{"input": prompt}, {"output": full_response}\n\t\t\t)\n\n\texcept Exception as e:\n\t\tst.error(e)\n"""'], {}), '(\n """\n# save the vectorstore in st.session_state\n# add semantic search prompt into memory prompt\n# integrate back into your chatbot\ndef ex14_basebot():\n\t# Prompt_template form from ex11\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tinput_prompt = prompt_template.format(\n\t\t\toccupation=dict_inputs["occupation"],\n\t\t\ttopic=dict_inputs["topic"],\n\t\t\tage=dict_inputs["age"],\n\t\t)\n\t\tst.session_state.input_prompt = input_prompt\n\n\tif "input_prompt" not in st.session_state:\n\t\tst.session_state.input_prompt = "Speak like Yoda from Star Wars"\n\n\tif "memory" not in st.session_state:\n\t\tst.session_state.memory = ConversationBufferWindowMemory(k=5)\n\n\t# step 1 save the memory from your chatbot\n\t# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint\n\tmemory_data = st.session_state.memory.load_memory_variables({})\n\tst.write(memory_data)\n\tst.session_state.prompt_template = f""\\"\n\t\t{st.session_state.input_prompt}\n\n\t\tThis is the last conversation history:\n\t\t{memory_data}""\\"\n\tst.write("new prompt template: ", st.session_state.prompt_template)\n\n\tst.session_state.vectorstore = vectorstore_creator()\n\n\t# Initialize chat history\n\tif "msg" not in st.session_state:\n\t\tst.session_state.msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t# query information\n\t\t\tif st.session_state.vectorstore:\n\t\t\t\tdocs = st.session_state.vectorstore.similarity_search(prompt)\n\t\t\t\tdocs = docs[0].page_content\n\t\t\t\t# add your query prompt\n\t\t\t\tvs_prompt = f""\\"\n\t\t\t\t\tYou should reference this search result to help your answer,\n\t\t\t\t\t{docs}\n\t\t\t\t\tif the search result does not anwer the query, please say you are unable to answer, do not make up an answer""\\"\n\t\t\telse:\n\t\t\t\tvs_prompt = ""\n\t\t\t# add query prompt to your memory prompt and send it to LLM\n\t\t\tst.session_state.prompt_template = (\n\t\t\t\tst.session_state.prompt_template + vs_prompt\n\t\t\t)\n\t\t\t# set user prompt in chat history\n\t\t\tst.session_state.msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t# streaming function\n\t\t\t\tfor response in chat_completion_stream_prompt(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.msg.append({"role": "assistant", "content": full_response})\n\t\t\tst.session_state.memory.save_context(\n\t\t\t\t{"input": prompt}, {"output": full_response}\n\t\t\t)\n\n\texcept Exception as e:\n\t\tst.error(e)\n"""\n )\n', (69091, 72216), True, 'import streamlit as st\n'), ((72203, 72239), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (72214, 72239), True, 'import streamlit as st\n'), ((72489, 72513), 'sqlite3.connect', 'sqlite3.connect', (['DB_NAME'], {}), '(DB_NAME)\n', (72504, 72513), False, 'import sqlite3\n'), ((72919, 72943), 'sqlite3.connect', 'sqlite3.connect', (['DB_NAME'], {}), '(DB_NAME)\n', (72934, 72943), False, 'import sqlite3\n'), ((72975, 72989), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (72987, 72989), False, 'from datetime import datetime\n'), ((73541, 73565), 'sqlite3.connect', 'sqlite3.connect', (['DB_NAME'], {}), '(DB_NAME)\n', (73556, 73565), False, 'import sqlite3\n'), ((73772, 73812), 'pandas.DataFrame', 'pd.DataFrame', (['rows'], {'columns': 'column_names'}), '(rows, columns=column_names)\n', (73784, 73812), True, 'import pandas as pd\n'), ((73814, 73830), 'streamlit.dataframe', 'st.dataframe', (['df'], {}), '(df)\n', (73826, 73830), True, 'import streamlit as st\n'), ((73866, 73911), 'streamlit.subheader', 'st.subheader', (['"""Exercise 15: Using a database"""'], {}), "('Exercise 15: Using a database')\n", (73878, 73911), True, 'import streamlit as st\n'), ((73913, 74049), 'streamlit.write', 'st.write', (['"""In this exercise, we will demonstrate how to create a database, as well as how to store and retrieve data from it."""'], {}), "(\n 'In this exercise, we will demonstrate how to create a database, as well as how to store and retrieve data from it.'\n )\n", (73921, 74049), True, 'import streamlit as st\n'), ((74041, 74071), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (74052, 74071), True, 'import streamlit as st\n'), ((74073, 75680), 'streamlit.code', 'st.code', (['"""\ndef ex15_initialise():\n\t# Create or check for the \'database\' directory in the current working directory\n\t# Set DB_NAME to be within the \'database\' directory at the top of main.py\n\t# Connect to the SQLite database\n\tconn = sqlite3.connect(DB_NAME)\n\tcursor = conn.cursor()\n\n\t# Conversation data table\n\tcursor.execute(\n\t\t""\\"\n\t\tCREATE TABLE IF NOT EXISTS data_table (\n\t\t\tid INTEGER PRIMARY KEY,\n\t\t\tdate TEXT NOT NULL UNIQUE,\n\t\t\tusername TEXT NOT NULL,\n\t\t\tchatbot_ans TEXT NOT NULL,\n\t\t\tuser_prompt TEXT NOT NULL,\n\t\t\ttokens TEXT\n\t\t)\n\t""\\"\n\t)\n\tconn.commit()\n\tconn.close()\n\ndef ex15_collect(username, chatbot_response, prompt):\n\t# collect data from bot\n\tconn = sqlite3.connect(DB_NAME)\n\tcursor = conn.cursor()\n\tnow = datetime.now() # Using ISO format for date\n\ttokens = len(chatbot_response) * 1.3\n\tcursor.execute(\n\t\t""\\"\n\t\tINSERT INTO data_table (date, username,chatbot_ans, user_prompt, tokens)\n\t\tVALUES (?, ?, ?, ?, ?)\n\t""\\",\n\t\t(now, username, chatbot_response, prompt, tokens),\n\t)\n\tconn.commit()\n\tconn.close()\n\n# implementing data collection and displaying\ndef ex15():\n\t# initialise database first\n\tex15_initialise()\n\t# collect some data\n\tex15_collect("yoda", "I am Yoda. The Force is strong with you", "Who are you?")\n\t# display data\n\t# Connect to the specified database\n\tconn = sqlite3.connect(DB_NAME)\n\tcursor = conn.cursor()\n\n\t# Fetch all data from data_table\n\tcursor.execute("SELECT * FROM data_table")\n\trows = cursor.fetchall()\n\tcolumn_names = [description[0] for description in cursor.description]\n\tdf = pd.DataFrame(rows, columns=column_names)\n\tst.dataframe(df)\n\tconn.close()\n"""'], {}), '(\n """\ndef ex15_initialise():\n\t# Create or check for the \'database\' directory in the current working directory\n\t# Set DB_NAME to be within the \'database\' directory at the top of main.py\n\t# Connect to the SQLite database\n\tconn = sqlite3.connect(DB_NAME)\n\tcursor = conn.cursor()\n\n\t# Conversation data table\n\tcursor.execute(\n\t\t""\\"\n\t\tCREATE TABLE IF NOT EXISTS data_table (\n\t\t\tid INTEGER PRIMARY KEY,\n\t\t\tdate TEXT NOT NULL UNIQUE,\n\t\t\tusername TEXT NOT NULL,\n\t\t\tchatbot_ans TEXT NOT NULL,\n\t\t\tuser_prompt TEXT NOT NULL,\n\t\t\ttokens TEXT\n\t\t)\n\t""\\"\n\t)\n\tconn.commit()\n\tconn.close()\n\ndef ex15_collect(username, chatbot_response, prompt):\n\t# collect data from bot\n\tconn = sqlite3.connect(DB_NAME)\n\tcursor = conn.cursor()\n\tnow = datetime.now() # Using ISO format for date\n\ttokens = len(chatbot_response) * 1.3\n\tcursor.execute(\n\t\t""\\"\n\t\tINSERT INTO data_table (date, username,chatbot_ans, user_prompt, tokens)\n\t\tVALUES (?, ?, ?, ?, ?)\n\t""\\",\n\t\t(now, username, chatbot_response, prompt, tokens),\n\t)\n\tconn.commit()\n\tconn.close()\n\n# implementing data collection and displaying\ndef ex15():\n\t# initialise database first\n\tex15_initialise()\n\t# collect some data\n\tex15_collect("yoda", "I am Yoda. The Force is strong with you", "Who are you?")\n\t# display data\n\t# Connect to the specified database\n\tconn = sqlite3.connect(DB_NAME)\n\tcursor = conn.cursor()\n\n\t# Fetch all data from data_table\n\tcursor.execute("SELECT * FROM data_table")\n\trows = cursor.fetchall()\n\tcolumn_names = [description[0] for description in cursor.description]\n\tdf = pd.DataFrame(rows, columns=column_names)\n\tst.dataframe(df)\n\tconn.close()\n"""\n )\n', (74080, 75680), True, 'import streamlit as st\n'), ((75668, 75704), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (75679, 75704), True, 'import streamlit as st\n'), ((75836, 76185), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['occupation', 'topic', 'age']", 'template': '"""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""'}), '(input_variables=[\'occupation\', \'topic\', \'age\'], template=\n """Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""\n )\n', (75850, 76185), False, 'from langchain.prompts import PromptTemplate\n'), ((76804, 76853), 'streamlit.session_state.memory.load_memory_variables', 'st.session_state.memory.load_memory_variables', (['{}'], {}), '({})\n', (76849, 76853), True, 'import streamlit as st\n'), ((76855, 76876), 'streamlit.write', 'st.write', (['memory_data'], {}), '(memory_data)\n', (76863, 76876), True, 'import streamlit as st\n'), ((77036, 77103), 'streamlit.write', 'st.write', (['"""new prompt template: """', 'st.session_state.prompt_template'], {}), "('new prompt template: ', st.session_state.prompt_template)\n", (77044, 77103), True, 'import streamlit as st\n'), ((78843, 78889), 'streamlit.subheader', 'st.subheader', (['"""Challenge 15: Using a database"""'], {}), "('Challenge 15: Using a database')\n", (78855, 78889), True, 'import streamlit as st\n'), ((78891, 78997), 'streamlit.write', 'st.write', (['"""For this challenge, we will incorporate using a database from our previous exercise."""'], {}), "(\n 'For this challenge, we will incorporate using a database from our previous exercise.'\n )\n", (78899, 78997), True, 'import streamlit as st\n'), ((78989, 79100), 'streamlit.write', 'st.write', (['"""Copy the code from ***ex14()*** and use the ***ex15()*** to collect and display the data."""'], {}), "(\n 'Copy the code from ***ex14()*** and use the ***ex15()*** to collect and display the data.'\n )\n", (78997, 79100), True, 'import streamlit as st\n'), ((79093, 79123), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (79104, 79123), True, 'import streamlit as st\n'), ((82271, 82307), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (82282, 82307), True, 'import streamlit as st\n'), ((82500, 82550), 'streamlit.title', 'st.title', (['"""🦜 LangChain: Chat with internet search"""'], {}), "('🦜 LangChain: Chat with internet search')\n", (82508, 82550), True, 'import streamlit as st\n'), ((82560, 82589), 'langchain.memory.chat_message_histories.StreamlitChatMessageHistory', 'StreamlitChatMessageHistory', ([], {}), '()\n', (82587, 82589), False, 'from langchain.memory.chat_message_histories import StreamlitChatMessageHistory\n'), ((82600, 82717), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'chat_memory': 'msgs', 'return_messages': '(True)', 'memory_key': '"""chat_history"""', 'output_key': '"""output"""'}), "(chat_memory=msgs, return_messages=True, memory_key\n ='chat_history', output_key='output')\n", (82624, 82717), False, 'from langchain.memory import ConversationBufferMemory\n'), ((84182, 84222), 'streamlit.subheader', 'st.subheader', (['"""Exercise 16: Smart agent"""'], {}), "('Exercise 16: Smart agent')\n", (84194, 84222), True, 'import streamlit as st\n'), ((84224, 84369), 'streamlit.write', 'st.write', (['"""In this exercise, we will configure a chatbot with an internet search tool that shows all intermediate steps and tool logs."""'], {}), "(\n 'In this exercise, we will configure a chatbot with an internet search tool that shows all intermediate steps and tool logs.'\n )\n", (84232, 84369), True, 'import streamlit as st\n'), ((84361, 84545), 'streamlit.write', 'st.write', (['"""This overcomes the limitation of the training data that is only up to a certain point in time, by being able to access the current internet to search for answers."""'], {}), "(\n 'This overcomes the limitation of the training data that is only up to a certain point in time, by being able to access the current internet to search for answers.'\n )\n", (84369, 84545), True, 'import streamlit as st\n'), ((84538, 84639), 'streamlit.write', 'st.write', (['"""You may need to run the following commands in terminal to install new libaries:"""'], {}), "(\n 'You may need to run the following commands in terminal to install new libaries:'\n )\n", (84546, 84639), True, 'import streamlit as st\n'), ((84631, 84677), 'streamlit.code', 'st.code', (['"""\npip install duckduckgo-search\n"""'], {}), '("""\npip install duckduckgo-search\n""")\n', (84638, 84677), True, 'import streamlit as st\n'), ((84681, 84711), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (84692, 84711), True, 'import streamlit as st\n'), ((84713, 86565), 'streamlit.code', 'st.code', (['"""\n# smart agents accessing the internet for free\n# https://github.com/langchain-ai/streamlit-agent/blob/main/streamlit_agent/search_and_chat.py\ndef ex16_agent_bot():\n\tst.title("🦜 LangChain: Chat with internet search")\n\n\tmsgs = StreamlitChatMessageHistory()\n\tmemory = ConversationBufferMemory(\n\t\tchat_memory=msgs,\n\t\treturn_messages=True,\n\t\tmemory_key="chat_history",\n\t\toutput_key="output",\n\t)\n\tif len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):\n\t\tmsgs.clear()\n\t\tmsgs.add_ai_message("How can I help you?")\n\t\tst.session_state.steps = {}\n\n\tavatars = {"human": "user", "ai": "assistant"}\n\tfor idx, msg in enumerate(msgs.messages):\n\t\twith st.chat_message(avatars[msg.type]):\n\t\t\t# Render intermediate steps if any were saved\n\t\t\tfor step in st.session_state.steps.get(str(idx), []):\n\t\t\t\tif step[0].tool == "_Exception":\n\t\t\t\t\tcontinue\n\t\t\t\twith st.status(\n\t\t\t\t\tf"**{step[0].tool}**: {step[0].tool_input}", state="complete"\n\t\t\t\t):\n\t\t\t\t\tst.write(step[0].log)\n\t\t\t\t\tst.write(step[1])\n\t\t\tst.write(msg.content)\n\n\tif prompt := st.chat_input(placeholder="Enter a query on the Internet"):\n\t\tst.chat_message("user").write(prompt)\n\n\t\tllm = ChatOpenAI(\n\t\t\tmodel_name="gpt-3.5-turbo", openai_api_key=openai_api_key, streaming=True\n\t\t)\n\t\ttools = [DuckDuckGoSearchRun(name="Search")]\n\t\tchat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)\n\t\texecutor = AgentExecutor.from_agent_and_tools(\n\t\t\tagent=chat_agent,\n\t\t\ttools=tools,\n\t\t\tmemory=memory,\n\t\t\treturn_intermediate_steps=True,\n\t\t\thandle_parsing_errors=True,\n\t\t)\n\t\twith st.chat_message("assistant"):\n\t\t\tst_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)\n\t\t\tresponse = executor(prompt, callbacks=[st_cb])\n\t\t\tst.write(response["output"])\n\t\t\tst.session_state.steps[str(len(msgs.messages) - 1)] = response[\n\t\t\t\t"intermediate_steps"\n\t\t\t]\n"""'], {}), '(\n """\n# smart agents accessing the internet for free\n# https://github.com/langchain-ai/streamlit-agent/blob/main/streamlit_agent/search_and_chat.py\ndef ex16_agent_bot():\n\tst.title("🦜 LangChain: Chat with internet search")\n\n\tmsgs = StreamlitChatMessageHistory()\n\tmemory = ConversationBufferMemory(\n\t\tchat_memory=msgs,\n\t\treturn_messages=True,\n\t\tmemory_key="chat_history",\n\t\toutput_key="output",\n\t)\n\tif len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):\n\t\tmsgs.clear()\n\t\tmsgs.add_ai_message("How can I help you?")\n\t\tst.session_state.steps = {}\n\n\tavatars = {"human": "user", "ai": "assistant"}\n\tfor idx, msg in enumerate(msgs.messages):\n\t\twith st.chat_message(avatars[msg.type]):\n\t\t\t# Render intermediate steps if any were saved\n\t\t\tfor step in st.session_state.steps.get(str(idx), []):\n\t\t\t\tif step[0].tool == "_Exception":\n\t\t\t\t\tcontinue\n\t\t\t\twith st.status(\n\t\t\t\t\tf"**{step[0].tool}**: {step[0].tool_input}", state="complete"\n\t\t\t\t):\n\t\t\t\t\tst.write(step[0].log)\n\t\t\t\t\tst.write(step[1])\n\t\t\tst.write(msg.content)\n\n\tif prompt := st.chat_input(placeholder="Enter a query on the Internet"):\n\t\tst.chat_message("user").write(prompt)\n\n\t\tllm = ChatOpenAI(\n\t\t\tmodel_name="gpt-3.5-turbo", openai_api_key=openai_api_key, streaming=True\n\t\t)\n\t\ttools = [DuckDuckGoSearchRun(name="Search")]\n\t\tchat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)\n\t\texecutor = AgentExecutor.from_agent_and_tools(\n\t\t\tagent=chat_agent,\n\t\t\ttools=tools,\n\t\t\tmemory=memory,\n\t\t\treturn_intermediate_steps=True,\n\t\t\thandle_parsing_errors=True,\n\t\t)\n\t\twith st.chat_message("assistant"):\n\t\t\tst_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)\n\t\t\tresponse = executor(prompt, callbacks=[st_cb])\n\t\t\tst.write(response["output"])\n\t\t\tst.session_state.steps[str(len(msgs.messages) - 1)] = response[\n\t\t\t\t"intermediate_steps"\n\t\t\t]\n"""\n )\n', (84720, 86565), True, 'import streamlit as st\n'), ((86557, 86593), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (86568, 86593), True, 'import streamlit as st\n'), ((86975, 87028), 'streamlit.session_state.vectorstore.similarity_search', 'st.session_state.vectorstore.similarity_search', (['query'], {}), '(query)\n', (87021, 87028), True, 'import streamlit as st\n'), ((87073, 87119), 'json.dumps', 'json.dumps', (['docs'], {'ensure_ascii': '(False)', 'indent': '(4)'}), '(docs, ensure_ascii=False, indent=4)\n', (87083, 87119), False, 'import json\n'), ((87197, 87247), 'streamlit.title', 'st.title', (['"""🦜 LangChain: Chat with internet search"""'], {}), "('🦜 LangChain: Chat with internet search')\n", (87205, 87247), True, 'import streamlit as st\n'), ((87312, 87341), 'langchain.memory.chat_message_histories.StreamlitChatMessageHistory', 'StreamlitChatMessageHistory', ([], {}), '()\n', (87339, 87341), False, 'from langchain.memory.chat_message_histories import StreamlitChatMessageHistory\n'), ((87352, 87469), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'chat_memory': 'msgs', 'return_messages': '(True)', 'memory_key': '"""chat_history"""', 'output_key': '"""output"""'}), "(chat_memory=msgs, return_messages=True, memory_key\n ='chat_history', output_key='output')\n", (87376, 87469), False, 'from langchain.memory import ConversationBufferMemory\n'), ((88960, 89018), 'streamlit.subheader', 'st.subheader', (['"""Exercise 17: Smart agent with vector store"""'], {}), "('Exercise 17: Smart agent with vector store')\n", (88972, 89018), True, 'import streamlit as st\n'), ((89020, 89109), 'streamlit.write', 'st.write', (['"""In this exercise, we will combine the vector store with the smart agent."""'], {}), "(\n 'In this exercise, we will combine the vector store with the smart agent.')\n", (89028, 89109), True, 'import streamlit as st\n'), ((89106, 89213), 'streamlit.write', 'st.write', (['"""This allows the chatbot to search for answers from the vector store and the internet."""'], {}), "(\n 'This allows the chatbot to search for answers from the vector store and the internet.'\n )\n", (89114, 89213), True, 'import streamlit as st\n'), ((89205, 89421), 'streamlit.write', 'st.write', (['"""The @tool("Document search") function is an enhancement to the chatbot. It allows for an initial internal document search based on the user query before resorting to external internet searches. """'], {}), '(\n \'The @tool("Document search") function is an enhancement to the chatbot. It allows for an initial internal document search based on the user query before resorting to external internet searches. \'\n )\n', (89213, 89421), True, 'import streamlit as st\n'), ((89415, 89484), 'streamlit.write', 'st.write', (['"""Copy and run the code below to see the chatbot in action."""'], {}), "('Copy and run the code below to see the chatbot in action.')\n", (89423, 89484), True, 'import streamlit as st\n'), ((89487, 89517), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (89498, 89517), True, 'import streamlit as st\n'), ((89519, 91871), 'streamlit.code', 'st.code', (['"""\n# agents ,vectorstores, wiki\n# https://python.langchain.com/docs/modules/agents/how_to/custom_agent_with_tool_retrieval\n# note tool\n@tool("Document search")\ndef document_search(query: str) -> str:\n\t# this is the prompt to the tool itself\n\t"Use this function first to search for documents pertaining to the query before going into the internet"\n\tdocs = st.session_state.vectorstore.similarity_search(query)\n\tdocs = docs[0].page_content\n\tjson_string = json.dumps(docs, ensure_ascii=False, indent=4)\n\treturn json_string\n\n# combine vector store and internet search\ndef ex17_agent_bot():\n\tst.title("🦜 LangChain: Chat with internet search")\n\n\tst.session_state.vectorstore = vectorstore_creator()\n\n\tmsgs = StreamlitChatMessageHistory()\n\tmemory = ConversationBufferMemory(\n\t\tchat_memory=msgs,\n\t\treturn_messages=True,\n\t\tmemory_key="chat_history",\n\t\toutput_key="output",\n\t)\n\tif len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):\n\t\tmsgs.clear()\n\t\tmsgs.add_ai_message("How can I help you?")\n\t\tst.session_state.steps = {}\n\n\tavatars = {"human": "user", "ai": "assistant"}\n\tfor idx, msg in enumerate(msgs.messages):\n\t\twith st.chat_message(avatars[msg.type]):\n\t\t\t# Render intermediate steps if any were saved\n\t\t\tfor step in st.session_state.steps.get(str(idx), []):\n\t\t\t\tif step[0].tool == "_Exception":\n\t\t\t\t\tcontinue\n\t\t\t\twith st.status(\n\t\t\t\t\tf"**{step[0].tool}**: {step[0].tool_input}", state="complete"\n\t\t\t\t):\n\t\t\t\t\tst.write(step[0].log)\n\t\t\t\t\tst.write(step[1])\n\t\t\tst.write(msg.content)\n\n\tif prompt := st.chat_input(placeholder="Enter a query on the Internet"):\n\t\tst.chat_message("user").write(prompt)\n\n\t\tllm = ChatOpenAI(\n\t\t\tmodel_name="gpt-3.5-turbo", openai_api_key=openai_api_key, streaming=True\n\t\t)\n\t\ttools = [document_search, DuckDuckGoSearchRun(name="Internet Search")]\n\t\tchat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)\n\t\texecutor = AgentExecutor.from_agent_and_tools(\n\t\t\tagent=chat_agent,\n\t\t\ttools=tools,\n\t\t\tmemory=memory,\n\t\t\treturn_intermediate_steps=True,\n\t\t\thandle_parsing_errors=True,\n\t\t)\n\t\twith st.chat_message("assistant"):\n\t\t\tst_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)\n\t\t\tresponse = executor(prompt, callbacks=[st_cb])\n\t\t\tst.write(response["output"])\n\t\t\tst.session_state.steps[str(len(msgs.messages) - 1)] = response[\n\t\t\t\t"intermediate_steps"\n\t\t\t]\n"""'], {}), '(\n """\n# agents ,vectorstores, wiki\n# https://python.langchain.com/docs/modules/agents/how_to/custom_agent_with_tool_retrieval\n# note tool\n@tool("Document search")\ndef document_search(query: str) -> str:\n\t# this is the prompt to the tool itself\n\t"Use this function first to search for documents pertaining to the query before going into the internet"\n\tdocs = st.session_state.vectorstore.similarity_search(query)\n\tdocs = docs[0].page_content\n\tjson_string = json.dumps(docs, ensure_ascii=False, indent=4)\n\treturn json_string\n\n# combine vector store and internet search\ndef ex17_agent_bot():\n\tst.title("🦜 LangChain: Chat with internet search")\n\n\tst.session_state.vectorstore = vectorstore_creator()\n\n\tmsgs = StreamlitChatMessageHistory()\n\tmemory = ConversationBufferMemory(\n\t\tchat_memory=msgs,\n\t\treturn_messages=True,\n\t\tmemory_key="chat_history",\n\t\toutput_key="output",\n\t)\n\tif len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):\n\t\tmsgs.clear()\n\t\tmsgs.add_ai_message("How can I help you?")\n\t\tst.session_state.steps = {}\n\n\tavatars = {"human": "user", "ai": "assistant"}\n\tfor idx, msg in enumerate(msgs.messages):\n\t\twith st.chat_message(avatars[msg.type]):\n\t\t\t# Render intermediate steps if any were saved\n\t\t\tfor step in st.session_state.steps.get(str(idx), []):\n\t\t\t\tif step[0].tool == "_Exception":\n\t\t\t\t\tcontinue\n\t\t\t\twith st.status(\n\t\t\t\t\tf"**{step[0].tool}**: {step[0].tool_input}", state="complete"\n\t\t\t\t):\n\t\t\t\t\tst.write(step[0].log)\n\t\t\t\t\tst.write(step[1])\n\t\t\tst.write(msg.content)\n\n\tif prompt := st.chat_input(placeholder="Enter a query on the Internet"):\n\t\tst.chat_message("user").write(prompt)\n\n\t\tllm = ChatOpenAI(\n\t\t\tmodel_name="gpt-3.5-turbo", openai_api_key=openai_api_key, streaming=True\n\t\t)\n\t\ttools = [document_search, DuckDuckGoSearchRun(name="Internet Search")]\n\t\tchat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)\n\t\texecutor = AgentExecutor.from_agent_and_tools(\n\t\t\tagent=chat_agent,\n\t\t\ttools=tools,\n\t\t\tmemory=memory,\n\t\t\treturn_intermediate_steps=True,\n\t\t\thandle_parsing_errors=True,\n\t\t)\n\t\twith st.chat_message("assistant"):\n\t\t\tst_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)\n\t\t\tresponse = executor(prompt, callbacks=[st_cb])\n\t\t\tst.write(response["output"])\n\t\t\tst.session_state.steps[str(len(msgs.messages) - 1)] = response[\n\t\t\t\t"intermediate_steps"\n\t\t\t]\n"""\n )\n', (89526, 91871), True, 'import streamlit as st\n'), ((91863, 91899), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (91874, 91899), True, 'import streamlit as st\n'), ((91997, 92038), 'streamlit.title', 'st.title', (['"""pandas-ai streamlit interface"""'], {}), "('pandas-ai streamlit interface')\n", (92005, 92038), True, 'import streamlit as st\n'), ((92099, 92148), 'streamlit.file_uploader', 'st.file_uploader', (['"""Choose a CSV file"""'], {'type': '"""csv"""'}), "('Choose a CSV file', type='csv')\n", (92115, 92148), True, 'import streamlit as st\n'), ((93144, 93174), 'os.path.join', 'os.path.join', (['"""exports/charts"""'], {}), "('exports/charts')\n", (93156, 93174), False, 'import os\n'), ((94162, 94193), 'streamlit.subheader', 'st.subheader', (['"""Prompt history:"""'], {}), "('Prompt history:')\n", (94174, 94193), True, 'import streamlit as st\n'), ((94195, 94236), 'streamlit.write', 'st.write', (['st.session_state.prompt_history'], {}), '(st.session_state.prompt_history)\n', (94203, 94236), True, 'import streamlit as st\n'), ((94242, 94260), 'streamlit.button', 'st.button', (['"""Clear"""'], {}), "('Clear')\n", (94251, 94260), True, 'import streamlit as st\n'), ((94351, 94394), 'streamlit.subheader', 'st.subheader', (['"""Exercise 18: Data Analytics"""'], {}), "('Exercise 18: Data Analytics')\n", (94363, 94394), True, 'import streamlit as st\n'), ((94396, 94496), 'streamlit.write', 'st.write', (['"""In this exercise, we will use the Pandas AI library to perform data analytics."""'], {}), "(\n 'In this exercise, we will use the Pandas AI library to perform data analytics.'\n )\n", (94404, 94496), True, 'import streamlit as st\n'), ((94488, 94596), 'streamlit.write', 'st.write', (['"""The Pandas AI library is a smart agent that can perform data analytics on a dataframe."""'], {}), "(\n 'The Pandas AI library is a smart agent that can perform data analytics on a dataframe.'\n )\n", (94496, 94596), True, 'import streamlit as st\n'), ((94588, 94646), 'streamlit.write', 'st.write', (['"""You may need to install the following library:"""'], {}), "('You may need to install the following library:')\n", (94596, 94646), True, 'import streamlit as st\n'), ((94648, 94674), 'streamlit.code', 'st.code', (['"""pip install bs4"""'], {}), "('pip install bs4')\n", (94655, 94674), True, 'import streamlit as st\n'), ((94680, 94749), 'streamlit.write', 'st.write', (['"""Copy and run the code below to see the chatbot in action."""'], {}), "('Copy and run the code below to see the chatbot in action.')\n", (94688, 94749), True, 'import streamlit as st\n'), ((94752, 94782), 'streamlit.markdown', 'st.markdown', (['"""**:blue[Code]**"""'], {}), "('**:blue[Code]**')\n", (94763, 94782), True, 'import streamlit as st\n'), ((94784, 97221), 'streamlit.code', 'st.code', (['"""\n# PandasAI- A smart agent that can do visual analytics\ndef ex18_pandas_AI():\n\tst.title("pandas-ai streamlit interface")\n\n\t# Upload CSV file using st.file_uploader\n\tuploaded_file = st.file_uploader("Choose a CSV file", type="csv")\n\tif "openai_key" not in st.session_state:\n\t\tst.session_state.openai_key = st.secrets["openapi_key"]\n\t\tst.session_state.prompt_history = []\n\t\tst.session_state.df = None\n\n\tif uploaded_file is not None:\n\t\ttry:\n\t\t\tdf = pd.read_csv(uploaded_file)\n\t\t\tst.session_state.df = df\n\t\texcept Exception as e:\n\t\t\tst.write("There was an error processing the CSV file.")\n\t\t\tst.write(e)\n\n\telse:\n\t\tst.session_state.df = pd.DataFrame(\n\t\t\t{\n\t\t\t\t"country": [\n\t\t\t\t\t"United States",\n\t\t\t\t\t"United Kingdom",\n\t\t\t\t\t"France",\n\t\t\t\t\t"Germany",\n\t\t\t\t\t"Italy",\n\t\t\t\t\t"Spain",\n\t\t\t\t\t"Canada",\n\t\t\t\t\t"Australia",\n\t\t\t\t\t"Japan",\n\t\t\t\t\t"China",\n\t\t\t\t],\n\t\t\t\t"gdp": [\n\t\t\t\t\t19294482071552,\n\t\t\t\t\t2891615567872,\n\t\t\t\t\t2411255037952,\n\t\t\t\t\t3435817336832,\n\t\t\t\t\t1745433788416,\n\t\t\t\t\t1181205135360,\n\t\t\t\t\t1607402389504,\n\t\t\t\t\t1490967855104,\n\t\t\t\t\t4380756541440,\n\t\t\t\t\t14631844184064,\n\t\t\t\t],\n\t\t\t\t"happiness_index": [\n\t\t\t\t\t6.94,\n\t\t\t\t\t7.16,\n\t\t\t\t\t6.66,\n\t\t\t\t\t7.07,\n\t\t\t\t\t6.38,\n\t\t\t\t\t6.4,\n\t\t\t\t\t7.23,\n\t\t\t\t\t7.22,\n\t\t\t\t\t5.87,\n\t\t\t\t\t5.12,\n\t\t\t\t],\n\t\t\t}\n\t\t)\n\tchart_path = os.path.join("exports/charts")\n\twith st.form("Question"):\n\t\tquestion = st.text_input("Question", value="", type="default")\n\t\tsubmitted = st.form_submit_button("Submit")\n\t\tif submitted:\n\t\t\twith st.spinner():\n\t\t\t\tllm = OpenAI(api_token=st.session_state.openai_key)\n\t\t\t\tdf = SmartDataframe(\n\t\t\t\t\tst.session_state.df,\n\t\t\t\t\tconfig={\n\t\t\t\t\t\t"llm": llm,\n\t\t\t\t\t\t"save_charts_path": chart_path,\n\t\t\t\t\t\t"save_charts": True,\n\t\t\t\t\t\t"verbose": True,\n\t\t\t\t\t},\n\t\t\t\t)\n\t\t\t\tresponse = df.chat(\n\t\t\t\t\tquestion\n\t\t\t\t) # Using \'chat\' method based on your context\n\n\t\t\t\t# Display the textual response (if any):\n\t\t\t\tif response:\n\t\t\t\t\tst.write(response)\n\t\t\t\tchart_path = os.path.join("exports/charts", "temp_chart.png")\n\t\t\t\tif os.path.exists(chart_path):\n\t\t\t\t\tst.image(\n\t\t\t\t\t\tchart_path, caption="Generated Chart", use_column_width=True\n\t\t\t\t\t)\n\t\t\t\t# Append the question to the history:\n\t\t\t\tst.session_state.prompt_history.append(question)\n\n\tif st.session_state.df is not None:\n\t\tst.subheader("Current dataframe:")\n\t\tst.write(st.session_state.df)\n\n\tst.subheader("Prompt history:")\n\tst.write(st.session_state.prompt_history)\n\n\tif st.button("Clear"):\n\t\tst.session_state.prompt_history = []\n\t\tst.session_state.df = None\n"""'], {}), '(\n """\n# PandasAI- A smart agent that can do visual analytics\ndef ex18_pandas_AI():\n\tst.title("pandas-ai streamlit interface")\n\n\t# Upload CSV file using st.file_uploader\n\tuploaded_file = st.file_uploader("Choose a CSV file", type="csv")\n\tif "openai_key" not in st.session_state:\n\t\tst.session_state.openai_key = st.secrets["openapi_key"]\n\t\tst.session_state.prompt_history = []\n\t\tst.session_state.df = None\n\n\tif uploaded_file is not None:\n\t\ttry:\n\t\t\tdf = pd.read_csv(uploaded_file)\n\t\t\tst.session_state.df = df\n\t\texcept Exception as e:\n\t\t\tst.write("There was an error processing the CSV file.")\n\t\t\tst.write(e)\n\n\telse:\n\t\tst.session_state.df = pd.DataFrame(\n\t\t\t{\n\t\t\t\t"country": [\n\t\t\t\t\t"United States",\n\t\t\t\t\t"United Kingdom",\n\t\t\t\t\t"France",\n\t\t\t\t\t"Germany",\n\t\t\t\t\t"Italy",\n\t\t\t\t\t"Spain",\n\t\t\t\t\t"Canada",\n\t\t\t\t\t"Australia",\n\t\t\t\t\t"Japan",\n\t\t\t\t\t"China",\n\t\t\t\t],\n\t\t\t\t"gdp": [\n\t\t\t\t\t19294482071552,\n\t\t\t\t\t2891615567872,\n\t\t\t\t\t2411255037952,\n\t\t\t\t\t3435817336832,\n\t\t\t\t\t1745433788416,\n\t\t\t\t\t1181205135360,\n\t\t\t\t\t1607402389504,\n\t\t\t\t\t1490967855104,\n\t\t\t\t\t4380756541440,\n\t\t\t\t\t14631844184064,\n\t\t\t\t],\n\t\t\t\t"happiness_index": [\n\t\t\t\t\t6.94,\n\t\t\t\t\t7.16,\n\t\t\t\t\t6.66,\n\t\t\t\t\t7.07,\n\t\t\t\t\t6.38,\n\t\t\t\t\t6.4,\n\t\t\t\t\t7.23,\n\t\t\t\t\t7.22,\n\t\t\t\t\t5.87,\n\t\t\t\t\t5.12,\n\t\t\t\t],\n\t\t\t}\n\t\t)\n\tchart_path = os.path.join("exports/charts")\n\twith st.form("Question"):\n\t\tquestion = st.text_input("Question", value="", type="default")\n\t\tsubmitted = st.form_submit_button("Submit")\n\t\tif submitted:\n\t\t\twith st.spinner():\n\t\t\t\tllm = OpenAI(api_token=st.session_state.openai_key)\n\t\t\t\tdf = SmartDataframe(\n\t\t\t\t\tst.session_state.df,\n\t\t\t\t\tconfig={\n\t\t\t\t\t\t"llm": llm,\n\t\t\t\t\t\t"save_charts_path": chart_path,\n\t\t\t\t\t\t"save_charts": True,\n\t\t\t\t\t\t"verbose": True,\n\t\t\t\t\t},\n\t\t\t\t)\n\t\t\t\tresponse = df.chat(\n\t\t\t\t\tquestion\n\t\t\t\t) # Using \'chat\' method based on your context\n\n\t\t\t\t# Display the textual response (if any):\n\t\t\t\tif response:\n\t\t\t\t\tst.write(response)\n\t\t\t\tchart_path = os.path.join("exports/charts", "temp_chart.png")\n\t\t\t\tif os.path.exists(chart_path):\n\t\t\t\t\tst.image(\n\t\t\t\t\t\tchart_path, caption="Generated Chart", use_column_width=True\n\t\t\t\t\t)\n\t\t\t\t# Append the question to the history:\n\t\t\t\tst.session_state.prompt_history.append(question)\n\n\tif st.session_state.df is not None:\n\t\tst.subheader("Current dataframe:")\n\t\tst.write(st.session_state.df)\n\n\tst.subheader("Prompt history:")\n\tst.write(st.session_state.prompt_history)\n\n\tif st.button("Clear"):\n\t\tst.session_state.prompt_history = []\n\t\tst.session_state.df = None\n"""\n )\n', (94791, 97221), True, 'import streamlit as st\n'), ((97213, 97249), 'streamlit.markdown', 'st.markdown', (['"""**:red[Code Output]**"""'], {}), "('**:red[Code Output]**')\n", (97224, 97249), True, 'import streamlit as st\n'), ((1605, 1631), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (1616, 1631), True, 'import streamlit as st\n'), ((1635, 1672), 'streamlit.code', 'st.code', (['"""\n#challenge code here\n"""'], {}), '("""\n#challenge code here\n""")\n', (1642, 1672), True, 'import streamlit as st\n'), ((10955, 10980), 'streamlit.write', 'st.write', (["('Hello ' + name)"], {}), "('Hello ' + name)\n", (10963, 10980), True, 'import streamlit as st\n'), ((12507, 12592), 'streamlit.text', 'st.text', (['f"""Hello {name}, you are {gender} and this year you are {age} years old"""'], {}), "(f'Hello {name}, you are {gender} and this year you are {age} years old'\n )\n", (12514, 12592), True, 'import streamlit as st\n'), ((13221, 13247), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (13232, 13247), True, 'import streamlit as st\n'), ((13251, 13587), 'streamlit.code', 'st.code', (['"""\ndef ch1():\n name = st.text_input("Enter your name")\n gender = st.selectbox("State your gender", ["Male", "Female"])\n age = st.text_input("State your age", 18)\n\n if name and gender and age:\n st.text(f"Hello {name}, you are {gender} and this year you are {age} years old")\n"""'], {}), '(\n """\ndef ch1():\n name = st.text_input("Enter your name")\n gender = st.selectbox("State your gender", ["Male", "Female"])\n age = st.text_input("State your age", 18)\n\n if name and gender and age:\n st.text(f"Hello {name}, you are {gender} and this year you are {age} years old")\n"""\n )\n', (13258, 13587), True, 'import streamlit as st\n'), ((13739, 13774), 'streamlit.text_input', 'st.text_input', (['"""State your age"""', '(18)'], {}), "('State your age', 18)\n", (13752, 13774), True, 'import streamlit as st\n'), ((13935, 13967), 'streamlit.write', 'st.write', (['"""You are a male adult"""'], {}), "('You are a male adult')\n", (13943, 13967), True, 'import streamlit as st\n'), ((14240, 14272), 'streamlit.write', 'st.write', (['"""Here is your photo: """'], {}), "('Here is your photo: ')\n", (14248, 14272), True, 'import streamlit as st\n'), ((14281, 14296), 'streamlit.image', 'st.image', (['photo'], {}), '(photo)\n', (14289, 14296), True, 'import streamlit as st\n'), ((14315, 14341), 'streamlit.write', 'st.write', (['"""No photo taken"""'], {}), "('No photo taken')\n", (14323, 14341), True, 'import streamlit as st\n'), ((15430, 15445), 'streamlit.write', 'st.write', (['fruit'], {}), '(fruit)\n', (15438, 15445), True, 'import streamlit as st\n'), ((18061, 18093), 'streamlit.write', 'st.write', (['"""session_data: """', 'data'], {}), "('session_data: ', data)\n", (18069, 18093), True, 'import streamlit as st\n'), ((19387, 19428), 'streamlit.write', 'st.write', (['"""name: """', 'st.session_state.name'], {}), "('name: ', st.session_state.name)\n", (19395, 19428), True, 'import streamlit as st\n'), ((19484, 19523), 'streamlit.write', 'st.write', (['"""age: """', 'st.session_state.age'], {}), "('age: ', st.session_state.age)\n", (19492, 19523), True, 'import streamlit as st\n'), ((19583, 19628), 'streamlit.write', 'st.write', (['"""gender: """', 'st.session_state.gender'], {}), "('gender: ', st.session_state.gender)\n", (19591, 19628), True, 'import streamlit as st\n'), ((22136, 22162), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (22147, 22162), True, 'import streamlit as st\n'), ((22166, 23451), 'streamlit.code', 'st.code', (['"""\ndef ch4():\n\tif "name" not in st.session_state:\n\t\tst.session_state.name = "Yoda"\n\n\tif "age" not in st.session_state:\n\t\tst.session_state.age = 999\n\n\tif "gender" not in st.session_state:\n\t\tst.session_state.gender = "male"\n\n\tif "prompt_template" not in st.session_state:\n\t\tst.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"\n\n\tst.write("session_state.name: ", st.session_state.name)\n\tst.write("session_state.age: ", st.session_state.age)\n\tst.write("session_state.gender: ", st.session_state.gender)\n\tst.write("session_state.prompt_template: ", st.session_state.prompt_template)\n\ndef main():\n\t# initialize session state, from ch4\n\tif "name" not in st.session_state:\n\t\tst.session_state.name = "Yoda"\n\n\tif "age" not in st.session_state:\n\t\tst.session_state.age = 999\n\n\tif "gender" not in st.session_state:\n\t\tst.session_state.gender = "male"\n\n\tif "prompt_template" not in st.session_state:\n\t\tst.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"\n\t\t \n\t#the rest of your code is below\n"""'], {}), '(\n """\ndef ch4():\n\tif "name" not in st.session_state:\n\t\tst.session_state.name = "Yoda"\n\n\tif "age" not in st.session_state:\n\t\tst.session_state.age = 999\n\n\tif "gender" not in st.session_state:\n\t\tst.session_state.gender = "male"\n\n\tif "prompt_template" not in st.session_state:\n\t\tst.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"\n\n\tst.write("session_state.name: ", st.session_state.name)\n\tst.write("session_state.age: ", st.session_state.age)\n\tst.write("session_state.gender: ", st.session_state.gender)\n\tst.write("session_state.prompt_template: ", st.session_state.prompt_template)\n\ndef main():\n\t# initialize session state, from ch4\n\tif "name" not in st.session_state:\n\t\tst.session_state.name = "Yoda"\n\n\tif "age" not in st.session_state:\n\t\tst.session_state.age = 999\n\n\tif "gender" not in st.session_state:\n\t\tst.session_state.gender = "male"\n\n\tif "prompt_template" not in st.session_state:\n\t\tst.session_state.prompt_template = "Speak like Yoda from Star Wars for every question that was asked, do not give a direct answer but ask more questions in the style of wise Yoda from Star Wars"\n\t\t \n\t#the rest of your code is below\n"""\n )\n', (22173, 23451), True, 'import streamlit as st\n'), ((23685, 23742), 'streamlit.write', 'st.write', (['f"""User has sent the following prompt: {prompt}"""'], {}), "(f'User has sent the following prompt: {prompt}')\n", (23693, 23742), True, 'import streamlit as st\n'), ((23745, 23786), 'streamlit.session_state.store_msg.append', 'st.session_state.store_msg.append', (['prompt'], {}), '(prompt)\n', (23778, 23786), True, 'import streamlit as st\n'), ((25229, 25257), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (25242, 25257), True, 'import streamlit as st\n'), ((25392, 25461), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (25424, 25461), True, 'import streamlit as st\n'), ((25658, 25734), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'assistant', 'content': response}"], {}), "({'role': 'assistant', 'content': response})\n", (25690, 25734), True, 'import streamlit as st\n'), ((27382, 27415), 'streamlit.chat_input', 'st.chat_input', (['"""Enter your query"""'], {}), "('Enter your query')\n", (27395, 27415), True, 'import streamlit as st\n'), ((28745, 28771), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (28756, 28771), True, 'import streamlit as st\n'), ((28775, 29813), 'streamlit.code', 'st.code', (['"""\n#Challenge 6 : Rule-based If-Else Chatbot\ndef ch6():\n\tst.markdown("**Rule Based Bot**")\n\n\t# Initialize chat history\n\tif "messages" not in st.session_state:\n\t\tst.session_state.messages = []\n\n\t# # Display chat messages from history on app rerun\n\tfor message in st.session_state.messages:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\n\t# React to user input\n\tif prompt := st.chat_input("Enter your query"):\n\t\tif prompt == "Hello":\n\t\t\treply = "Hi there what can I do for you"\n\n\t\telif prompt == "What is your name?":\n\t\t\treply = "My name is EAI , an electronic artificial being"\n\n\t\telif prompt == "How old are you?":\n\t\t\treply = "Today is my birthday!"\n\t\t\n\t\telse:\n\t\t\treply = "I am sorry, I am unable to help you with your query"\n\n\t\twith st.chat_message("user"):\n\t\t\tst.write(prompt)\n\t\t\tst.session_state.messages.append({"role": "user", "content": prompt})\n\t\twith st.chat_message("assistant"):\n\t\t\tst.write(reply)\n\t\t\tst.session_state.messages.append({"role": "assistant", "content": reply})\n"""'], {}), '(\n """\n#Challenge 6 : Rule-based If-Else Chatbot\ndef ch6():\n\tst.markdown("**Rule Based Bot**")\n\n\t# Initialize chat history\n\tif "messages" not in st.session_state:\n\t\tst.session_state.messages = []\n\n\t# # Display chat messages from history on app rerun\n\tfor message in st.session_state.messages:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\n\t# React to user input\n\tif prompt := st.chat_input("Enter your query"):\n\t\tif prompt == "Hello":\n\t\t\treply = "Hi there what can I do for you"\n\n\t\telif prompt == "What is your name?":\n\t\t\treply = "My name is EAI , an electronic artificial being"\n\n\t\telif prompt == "How old are you?":\n\t\t\treply = "Today is my birthday!"\n\t\t\n\t\telse:\n\t\t\treply = "I am sorry, I am unable to help you with your query"\n\n\t\twith st.chat_message("user"):\n\t\t\tst.write(prompt)\n\t\t\tst.session_state.messages.append({"role": "user", "content": prompt})\n\t\twith st.chat_message("assistant"):\n\t\t\tst.write(reply)\n\t\t\tst.session_state.messages.append({"role": "assistant", "content": reply})\n"""\n )\n', (28782, 29813), True, 'import streamlit as st\n'), ((34282, 34308), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (34293, 34308), True, 'import streamlit as st\n'), ((34312, 35567), 'streamlit.code', 'st.code', (['"""\t\n#Challenge 8: Incorporating the API into your chatbot\ndef chat_completion(prompt):\n\tMODEL = "gpt-3.5-turbo"\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": "You are a helpful assistant."},\n\t\t\t{"role": "user", "content": prompt},\n\t\t],\n\t\ttemperature=0,\n\t)\n\treturn response["choices"][0]["message"]["content"].strip()\n\t\ndef ch8():\n\tst.title("My first LLM Chatbot")\n\n\t# Initialize chat history\n\tif "chat_msg" not in st.session_state:\n\t\tst.session_state.chat_msg = []\n\n\t# Display chat chat_msg from history on app rerun\n\tfor message in st.session_state.chat_msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\n\t# React to user input\n\tif prompt := st.chat_input("What\'s up?"):\n\t\t# Display user message in chat message container\n\t\treply = chat_completion(prompt)\n\t\tst.chat_message("user").markdown(prompt)\n\t\t# Add user message to chat history\n\t\tst.session_state.chat_msg.append({"role": "user", "content": prompt})\n\t\t# Display assistant response in chat message container\n\t\twith st.chat_message("assistant"):\n\t\t\tst.markdown(reply)\n\t\t# Add assistant response to chat history\n\t\tst.session_state.chat_msg.append({"role": "assistant", "content": reply})\n"""'], {}), '(\n """\t\n#Challenge 8: Incorporating the API into your chatbot\ndef chat_completion(prompt):\n\tMODEL = "gpt-3.5-turbo"\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": "You are a helpful assistant."},\n\t\t\t{"role": "user", "content": prompt},\n\t\t],\n\t\ttemperature=0,\n\t)\n\treturn response["choices"][0]["message"]["content"].strip()\n\t\ndef ch8():\n\tst.title("My first LLM Chatbot")\n\n\t# Initialize chat history\n\tif "chat_msg" not in st.session_state:\n\t\tst.session_state.chat_msg = []\n\n\t# Display chat chat_msg from history on app rerun\n\tfor message in st.session_state.chat_msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\n\t# React to user input\n\tif prompt := st.chat_input("What\'s up?"):\n\t\t# Display user message in chat message container\n\t\treply = chat_completion(prompt)\n\t\tst.chat_message("user").markdown(prompt)\n\t\t# Add user message to chat history\n\t\tst.session_state.chat_msg.append({"role": "user", "content": prompt})\n\t\t# Display assistant response in chat message container\n\t\twith st.chat_message("assistant"):\n\t\t\tst.markdown(reply)\n\t\t# Add assistant response to chat history\n\t\tst.session_state.chat_msg.append({"role": "assistant", "content": reply})\n"""\n )\n', (34319, 35567), True, 'import streamlit as st\n'), ((35934, 35962), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (35947, 35962), True, 'import streamlit as st\n'), ((36131, 36200), 'streamlit.session_state.chat_msg.append', 'st.session_state.chat_msg.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (36163, 36200), True, 'import streamlit as st\n'), ((36362, 36435), 'streamlit.session_state.chat_msg.append', 'st.session_state.chat_msg.append', (["{'role': 'assistant', 'content': reply}"], {}), "({'role': 'assistant', 'content': reply})\n", (36394, 36435), True, 'import streamlit as st\n'), ((44324, 44350), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (44335, 44350), True, 'import streamlit as st\n'), ((44354, 45895), 'streamlit.code', 'st.code', (['"""\n#Challenge 10\n#mod chat complete stream function by replacing system content to session_state prompt template\ndef chat_completion_stream_prompt(prompt):\n\tMODEL = "gpt-3.5-turbo" #consider changing this to session_state\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": st.session_state.prompt_template},\n\t\t\t{"role": "user", "content": prompt},\n\t\t],\n\t\ttemperature= 0, # temperature\n\t\tstream=True #stream option\n\t)\n\treturn response\n\n# Challenge 10: Make the bot speak like someone you know\ndef ch10_basebot():\n\t# call the function in your base bot\n\t# Initialize chat history\n\tif "msg" not in st.session_state:\n\t\tst.session_state.msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t#set user prompt in chat history\n\t\t\tst.session_state.msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t#streaming function\n\t\t\t\tfor response in chat_completion_stream_prompt(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.msg.append({"role": "assistant", "content": full_response})\n\n\texcept Exception as e:\n\t\tst.error(e)\n"""'], {}), '(\n """\n#Challenge 10\n#mod chat complete stream function by replacing system content to session_state prompt template\ndef chat_completion_stream_prompt(prompt):\n\tMODEL = "gpt-3.5-turbo" #consider changing this to session_state\n\tresponse = openai.ChatCompletion.create(\n\t\tmodel=MODEL,\n\t\tmessages=[\n\t\t\t{"role": "system", "content": st.session_state.prompt_template},\n\t\t\t{"role": "user", "content": prompt},\n\t\t],\n\t\ttemperature= 0, # temperature\n\t\tstream=True #stream option\n\t)\n\treturn response\n\n# Challenge 10: Make the bot speak like someone you know\ndef ch10_basebot():\n\t# call the function in your base bot\n\t# Initialize chat history\n\tif "msg" not in st.session_state:\n\t\tst.session_state.msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t#set user prompt in chat history\n\t\t\tst.session_state.msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t#streaming function\n\t\t\t\tfor response in chat_completion_stream_prompt(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.msg.append({"role": "assistant", "content": full_response})\n\n\texcept Exception as e:\n\t\tst.error(e)\n"""\n )\n', (44361, 45895), True, 'import streamlit as st\n'), ((46626, 46666), 'streamlit.write', 'st.write', (['"""Input prompt: """', 'input_prompt'], {}), "('Input prompt: ', input_prompt)\n", (46634, 46666), True, 'import streamlit as st\n'), ((48045, 48071), 'streamlit.form', 'st.form', (['"""Prompt Template"""'], {}), "('Prompt Template')\n", (48052, 48071), True, 'import streamlit as st\n'), ((48088, 48126), 'streamlit.text_input', 'st.text_input', (['"""Enter the occupation:"""'], {}), "('Enter the occupation:')\n", (48101, 48126), True, 'import streamlit as st\n'), ((48137, 48170), 'streamlit.text_input', 'st.text_input', (['"""Enter the topic:"""'], {}), "('Enter the topic:')\n", (48150, 48170), True, 'import streamlit as st\n'), ((48179, 48210), 'streamlit.text_input', 'st.text_input', (['"""Enter the age:"""'], {}), "('Enter the age:')\n", (48192, 48210), True, 'import streamlit as st\n'), ((48267, 48298), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""Submit"""'], {}), "('Submit')\n", (48288, 48298), True, 'import streamlit as st\n'), ((51721, 51782), 'streamlit.write', 'st.write', (['"""New session_state.prompt_template: """', 'input_prompt'], {}), "('New session_state.prompt_template: ', input_prompt)\n", (51729, 51782), True, 'import streamlit as st\n'), ((52639, 52665), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (52650, 52665), True, 'import streamlit as st\n'), ((52669, 53613), 'streamlit.code', 'st.code', (['"""\ndef ch11():\n\t# instead of running of the langchain, we are going to use the prompt template and run it the chatbot using format\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tinput_prompt = prompt_template.format(\n\t\t\toccupation=dict_inputs["occupation"],\n\t\t\ttopic=dict_inputs["topic"],\n\t\t\tage=dict_inputs["age"],\n\t\t)\n\t\t# set session_state.prompt_template\n\t\tst.session_state.prompt_template = input_prompt\n\t\tst.write("New session_state.prompt_template: ", input_prompt)\n\t# call the ch10() basebot with the new session_state.prompt_template\n\tch10()\n"""'], {}), '(\n """\ndef ch11():\n\t# instead of running of the langchain, we are going to use the prompt template and run it the chatbot using format\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tinput_prompt = prompt_template.format(\n\t\t\toccupation=dict_inputs["occupation"],\n\t\t\ttopic=dict_inputs["topic"],\n\t\t\tage=dict_inputs["age"],\n\t\t)\n\t\t# set session_state.prompt_template\n\t\tst.session_state.prompt_template = input_prompt\n\t\tst.write("New session_state.prompt_template: ", input_prompt)\n\t# call the ch10() basebot with the new session_state.prompt_template\n\tch10()\n"""\n )\n', (52676, 53613), True, 'import streamlit as st\n'), ((55833, 55868), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'k': '(3)'}), '(k=3)\n', (55863, 55868), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((58563, 58589), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (58574, 58589), True, 'import streamlit as st\n'), ((58593, 60969), 'streamlit.code', 'st.code', (['"""\ndef ch12():\n\t# Prompt_template form from ex11\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tinput_prompt = prompt_template.format(\n\t\t\toccupation=dict_inputs["occupation"],\n\t\t\ttopic=dict_inputs["topic"],\n\t\t\tage=dict_inputs["age"],\n\t\t)\n\telse:\n\t\tinput_prompt = "You are a helpful assistant. "\n\n\tst.write("input prompt: ", input_prompt)\n\n\tif "memory" not in st.session_state:\n\t\tst.session_state.memory = ConversationBufferWindowMemory(k=3)\n\n\t# step 1 save the memory from your chatbot\n\t# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint\n\tmemory_data = st.session_state.memory.load_memory_variables({})\n\tst.write("Memory Data: ", memory_data)\n\tst.session_state.prompt_template = f""\\"\n{input_prompt}\t\t\t\t\t\t\t\t\t\t\n\nBelow is the conversation history between the AI and Users so far\n\t\t\t\t\t\t\t\t\t\t\n{memory_data}\n\n""\\"\n\n\tst.write("New prompt template: ", st.session_state.prompt_template)\n\t# call the function in your base bot\n\t# Initialize chat history\n\tif "msg" not in st.session_state:\n\t\tst.session_state.msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t# set user prompt in chat history\n\t\t\tst.session_state.msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t# streaming function\n\t\t\t\tfor response in chat_completion_stream_prompt(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.msg.append({"role": "assistant", "content": full_response})\n\t\t\tst.session_state.memory.save_context(\n\t\t\t\t{"input": prompt}, {"output": full_response}\n\t\t\t)\n\texcept Exception as e:\n\t\tst.error(e)\n"""'], {}), '(\n """\ndef ch12():\n\t# Prompt_template form from ex11\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tinput_prompt = prompt_template.format(\n\t\t\toccupation=dict_inputs["occupation"],\n\t\t\ttopic=dict_inputs["topic"],\n\t\t\tage=dict_inputs["age"],\n\t\t)\n\telse:\n\t\tinput_prompt = "You are a helpful assistant. "\n\n\tst.write("input prompt: ", input_prompt)\n\n\tif "memory" not in st.session_state:\n\t\tst.session_state.memory = ConversationBufferWindowMemory(k=3)\n\n\t# step 1 save the memory from your chatbot\n\t# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint\n\tmemory_data = st.session_state.memory.load_memory_variables({})\n\tst.write("Memory Data: ", memory_data)\n\tst.session_state.prompt_template = f""\\"\n{input_prompt}\t\t\t\t\t\t\t\t\t\t\n\nBelow is the conversation history between the AI and Users so far\n\t\t\t\t\t\t\t\t\t\t\n{memory_data}\n\n""\\"\n\n\tst.write("New prompt template: ", st.session_state.prompt_template)\n\t# call the function in your base bot\n\t# Initialize chat history\n\tif "msg" not in st.session_state:\n\t\tst.session_state.msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t# set user prompt in chat history\n\t\t\tst.session_state.msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t# streaming function\n\t\t\t\tfor response in chat_completion_stream_prompt(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.msg.append({"role": "assistant", "content": full_response})\n\t\t\tst.session_state.memory.save_context(\n\t\t\t\t{"input": prompt}, {"output": full_response}\n\t\t\t)\n\texcept Exception as e:\n\t\tst.error(e)\n"""\n )\n', (58600, 60969), True, 'import streamlit as st\n'), ((62423, 62450), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['temp_file_path'], {}), '(temp_file_path)\n', (62434, 62450), False, 'from langchain.document_loaders import TextLoader, PyPDFLoader\n'), ((62496, 62559), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['documents', 'embeddings'], {'connection': 'table'}), '(documents, embeddings, connection=table)\n', (62518, 62559), False, 'from langchain.vectorstores import LanceDB\n'), ((62794, 62824), 'streamlit.text_input', 'st.text_input', (['"""Enter a query"""'], {}), "('Enter a query')\n", (62807, 62824), True, 'import streamlit as st\n'), ((66392, 66427), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'k': '(5)'}), '(k=5)\n', (66422, 66427), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((76607, 76642), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'k': '(5)'}), '(k=5)\n', (76637, 76642), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((79130, 79156), 'streamlit.expander', 'st.expander', (['"""Reveal Code"""'], {}), "('Reveal Code')\n", (79141, 79156), True, 'import streamlit as st\n'), ((79160, 82280), 'streamlit.code', 'st.code', (['"""\ndef ch15_chatbot():\n\t#display ex15 table\n\tex15()\n\t# Prompt_template form from ex11\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tinput_prompt = prompt_template.format(\n\t\t\toccupation=dict_inputs["occupation"],\n\t\t\ttopic=dict_inputs["topic"],\n\t\t\tage=dict_inputs["age"],\n\t\t)\n\t\tst.session_state.input_prompt = input_prompt\n\n\tif "input_prompt" not in st.session_state:\n\t\tst.session_state.input_prompt = "Speak like Yoda from Star Wars"\n\n\tif "memory" not in st.session_state:\n\t\tst.session_state.memory = ConversationBufferWindowMemory(k=5)\n\n\t# step 1 save the memory from your chatbot\n\t# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint\n\tmemory_data = st.session_state.memory.load_memory_variables({})\n\tst.write(memory_data)\n\tst.session_state.prompt_template = f""\\"{st.session_state.input_prompt}\n\t\t\t\t\t\t\t\t\t\tThis is the last conversation history\n\t\t\t\t\t\t\t\t\t\t{memory_data}\n\t\t\t\t\t\t\t\t\t\t""\\"\n\tst.write("new prompt template: ", st.session_state.prompt_template)\n\n\tst.session_state.vectorstore = vectorstore_creator()\n\n\t# Initialize chat history\n\tif "msg" not in st.session_state:\n\t\tst.session_state.msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t# query information\n\t\t\tif st.session_state.vectorstore:\n\t\t\t\tdocs = st.session_state.vectorstore.similarity_search(prompt)\n\t\t\t\tdocs = docs[0].page_content\n\t\t\t\t# add your query prompt\n\t\t\t\tvs_prompt = f""\\"You should reference this search result to help your answer,\n\t\t\t\t\t\t\t\t{docs}\n\t\t\t\t\t\t\t\tif the search result does not anwer the query, please say you are unable to answer, do not make up an answer""\\"\n\t\t\telse:\n\t\t\t\tvs_prompt = ""\n\t\t\t# add query prompt to your memory prompt and send it to LLM\n\t\t\tst.session_state.prompt_template = (\n\t\t\t\tst.session_state.prompt_template + vs_prompt\n\t\t\t)\n\t\t\t# set user prompt in chat history\n\t\t\tst.session_state.msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t# streaming function\n\t\t\t\tfor response in chat_completion_stream_prompt(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.msg.append({"role": "assistant", "content": full_response})\n\t\t\tst.session_state.memory.save_context(\n\t\t\t\t{"input": prompt}, {"output": full_response}\n\t\t\t)\n\n\t\t\tex15_collect(st.session_state.name, full_response, prompt)\n\n\texcept Exception as e:\n\t\tst.error(e)\n"""'], {}), '(\n """\ndef ch15_chatbot():\n\t#display ex15 table\n\tex15()\n\t# Prompt_template form from ex11\n\tprompt_template = PromptTemplate(\n\t\tinput_variables=["occupation", "topic", "age"],\n\t\ttemplate=""\\"Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""\\",\n\t)\n\tdict_inputs = prompt_inputs_form()\n\tif dict_inputs:\n\t\tinput_prompt = prompt_template.format(\n\t\t\toccupation=dict_inputs["occupation"],\n\t\t\ttopic=dict_inputs["topic"],\n\t\t\tage=dict_inputs["age"],\n\t\t)\n\t\tst.session_state.input_prompt = input_prompt\n\n\tif "input_prompt" not in st.session_state:\n\t\tst.session_state.input_prompt = "Speak like Yoda from Star Wars"\n\n\tif "memory" not in st.session_state:\n\t\tst.session_state.memory = ConversationBufferWindowMemory(k=5)\n\n\t# step 1 save the memory from your chatbot\n\t# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint\n\tmemory_data = st.session_state.memory.load_memory_variables({})\n\tst.write(memory_data)\n\tst.session_state.prompt_template = f""\\"{st.session_state.input_prompt}\n\t\t\t\t\t\t\t\t\t\tThis is the last conversation history\n\t\t\t\t\t\t\t\t\t\t{memory_data}\n\t\t\t\t\t\t\t\t\t\t""\\"\n\tst.write("new prompt template: ", st.session_state.prompt_template)\n\n\tst.session_state.vectorstore = vectorstore_creator()\n\n\t# Initialize chat history\n\tif "msg" not in st.session_state:\n\t\tst.session_state.msg = []\n\n\t# Showing Chat history\n\tfor message in st.session_state.msg:\n\t\twith st.chat_message(message["role"]):\n\t\t\tst.markdown(message["content"])\n\ttry:\n\t\t#\n\t\tif prompt := st.chat_input("What is up?"):\n\t\t\t# query information\n\t\t\tif st.session_state.vectorstore:\n\t\t\t\tdocs = st.session_state.vectorstore.similarity_search(prompt)\n\t\t\t\tdocs = docs[0].page_content\n\t\t\t\t# add your query prompt\n\t\t\t\tvs_prompt = f""\\"You should reference this search result to help your answer,\n\t\t\t\t\t\t\t\t{docs}\n\t\t\t\t\t\t\t\tif the search result does not anwer the query, please say you are unable to answer, do not make up an answer""\\"\n\t\t\telse:\n\t\t\t\tvs_prompt = ""\n\t\t\t# add query prompt to your memory prompt and send it to LLM\n\t\t\tst.session_state.prompt_template = (\n\t\t\t\tst.session_state.prompt_template + vs_prompt\n\t\t\t)\n\t\t\t# set user prompt in chat history\n\t\t\tst.session_state.msg.append({"role": "user", "content": prompt})\n\t\t\twith st.chat_message("user"):\n\t\t\t\tst.markdown(prompt)\n\n\t\t\twith st.chat_message("assistant"):\n\t\t\t\tmessage_placeholder = st.empty()\n\t\t\t\tfull_response = ""\n\t\t\t\t# streaming function\n\t\t\t\tfor response in chat_completion_stream_prompt(prompt):\n\t\t\t\t\tfull_response += response.choices[0].delta.get("content", "")\n\t\t\t\t\tmessage_placeholder.markdown(full_response + "▌")\n\t\t\t\tmessage_placeholder.markdown(full_response)\n\t\t\tst.session_state.msg.append({"role": "assistant", "content": full_response})\n\t\t\tst.session_state.memory.save_context(\n\t\t\t\t{"input": prompt}, {"output": full_response}\n\t\t\t)\n\n\t\t\tex15_collect(st.session_state.name, full_response, prompt)\n\n\texcept Exception as e:\n\t\tst.error(e)\n"""\n )\n', (79167, 82280), True, 'import streamlit as st\n'), ((82756, 82795), 'streamlit.sidebar.button', 'st.sidebar.button', (['"""Reset chat history"""'], {}), "('Reset chat history')\n", (82773, 82795), True, 'import streamlit as st\n'), ((83363, 83421), 'streamlit.chat_input', 'st.chat_input', ([], {'placeholder': '"""Enter a query on the Internet"""'}), "(placeholder='Enter a query on the Internet')\n", (83376, 83421), True, 'import streamlit as st\n'), ((83472, 83561), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'openai_api_key': 'openai.api_key', 'streaming': '(True)'}), "(model_name='gpt-3.5-turbo', openai_api_key=openai.api_key,\n streaming=True)\n", (83482, 83561), False, 'from langchain.chat_models import ChatOpenAI\n'), ((83627, 83691), 'langchain.agents.ConversationalChatAgent.from_llm_and_tools', 'ConversationalChatAgent.from_llm_and_tools', ([], {'llm': 'llm', 'tools': 'tools'}), '(llm=llm, tools=tools)\n', (83669, 83691), False, 'from langchain.agents import ConversationalChatAgent, AgentExecutor\n'), ((83705, 83850), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'chat_agent', 'tools': 'tools', 'memory': 'memory', 'return_intermediate_steps': '(True)', 'handle_parsing_errors': '(True)'}), '(agent=chat_agent, tools=tools, memory=\n memory, return_intermediate_steps=True, handle_parsing_errors=True)\n', (83739, 83850), False, 'from langchain.agents import ConversationalChatAgent, AgentExecutor\n'), ((87508, 87547), 'streamlit.sidebar.button', 'st.sidebar.button', (['"""Reset chat history"""'], {}), "('Reset chat history')\n", (87525, 87547), True, 'import streamlit as st\n'), ((88115, 88173), 'streamlit.chat_input', 'st.chat_input', ([], {'placeholder': '"""Enter a query on the Internet"""'}), "(placeholder='Enter a query on the Internet')\n", (88128, 88173), True, 'import streamlit as st\n'), ((88224, 88313), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'openai_api_key': 'openai.api_key', 'streaming': '(True)'}), "(model_name='gpt-3.5-turbo', openai_api_key=openai.api_key,\n streaming=True)\n", (88234, 88313), False, 'from langchain.chat_models import ChatOpenAI\n'), ((88405, 88469), 'langchain.agents.ConversationalChatAgent.from_llm_and_tools', 'ConversationalChatAgent.from_llm_and_tools', ([], {'llm': 'llm', 'tools': 'tools'}), '(llm=llm, tools=tools)\n', (88447, 88469), False, 'from langchain.agents import ConversationalChatAgent, AgentExecutor\n'), ((88483, 88628), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'chat_agent', 'tools': 'tools', 'memory': 'memory', 'return_intermediate_steps': '(True)', 'handle_parsing_errors': '(True)'}), '(agent=chat_agent, tools=tools, memory=\n memory, return_intermediate_steps=True, handle_parsing_errors=True)\n', (88517, 88628), False, 'from langchain.agents import ConversationalChatAgent, AgentExecutor\n'), ((92550, 92956), 'pandas.DataFrame', 'pd.DataFrame', (["{'country': ['United States', 'United Kingdom', 'France', 'Germany',\n 'Italy', 'Spain', 'Canada', 'Australia', 'Japan', 'China'], 'gdp': [\n 19294482071552, 2891615567872, 2411255037952, 3435817336832, \n 1745433788416, 1181205135360, 1607402389504, 1490967855104, \n 4380756541440, 14631844184064], 'happiness_index': [6.94, 7.16, 6.66, \n 7.07, 6.38, 6.4, 7.23, 7.22, 5.87, 5.12]}"], {}), "({'country': ['United States', 'United Kingdom', 'France',\n 'Germany', 'Italy', 'Spain', 'Canada', 'Australia', 'Japan', 'China'],\n 'gdp': [19294482071552, 2891615567872, 2411255037952, 3435817336832, \n 1745433788416, 1181205135360, 1607402389504, 1490967855104, \n 4380756541440, 14631844184064], 'happiness_index': [6.94, 7.16, 6.66, \n 7.07, 6.38, 6.4, 7.23, 7.22, 5.87, 5.12]})\n", (92562, 92956), True, 'import pandas as pd\n'), ((93181, 93200), 'streamlit.form', 'st.form', (['"""Question"""'], {}), "('Question')\n", (93188, 93200), True, 'import streamlit as st\n'), ((93215, 93266), 'streamlit.text_input', 'st.text_input', (['"""Question"""'], {'value': '""""""', 'type': '"""default"""'}), "('Question', value='', type='default')\n", (93228, 93266), True, 'import streamlit as st\n'), ((93281, 93312), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""Submit"""'], {}), "('Submit')\n", (93302, 93312), True, 'import streamlit as st\n'), ((94093, 94127), 'streamlit.subheader', 'st.subheader', (['"""Current dataframe:"""'], {}), "('Current dataframe:')\n", (94105, 94127), True, 'import streamlit as st\n'), ((94130, 94159), 'streamlit.write', 'st.write', (['st.session_state.df'], {}), '(st.session_state.df)\n', (94138, 94159), True, 'import streamlit as st\n'), ((8292, 8324), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (8307, 8324), True, 'import streamlit as st\n'), ((8329, 8360), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (8340, 8360), True, 'import streamlit as st\n'), ((8385, 8413), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (8398, 8413), True, 'import streamlit as st\n'), ((8418, 8486), 'streamlit.session_state.msg_bot.append', 'st.session_state.msg_bot.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (8449, 8486), True, 'import streamlit as st\n'), ((9063, 9148), 'streamlit.session_state.msg_bot.append', 'st.session_state.msg_bot.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content': full_response}\n )\n", (9094, 9148), True, 'import streamlit as st\n'), ((9171, 9182), 'streamlit.error', 'st.error', (['e'], {}), '(e)\n', (9179, 9182), True, 'import streamlit as st\n'), ((14016, 14047), 'streamlit.write', 'st.write', (['"""You are a young boy"""'], {}), "('You are a young boy')\n", (14024, 14047), True, 'import streamlit as st\n'), ((25122, 25154), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (25137, 25154), True, 'import streamlit as st\n'), ((25159, 25190), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (25170, 25190), True, 'import streamlit as st\n'), ((25558, 25586), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (25573, 25586), True, 'import streamlit as st\n'), ((25591, 25612), 'streamlit.markdown', 'st.markdown', (['response'], {}), '(response)\n', (25602, 25612), True, 'import streamlit as st\n'), ((27275, 27307), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (27290, 27307), True, 'import streamlit as st\n'), ((27312, 27343), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (27323, 27343), True, 'import streamlit as st\n'), ((27743, 27766), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (27758, 27766), True, 'import streamlit as st\n'), ((27771, 27787), 'streamlit.write', 'st.write', (['prompt'], {}), '(prompt)\n', (27779, 27787), True, 'import streamlit as st\n'), ((27791, 27860), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (27823, 27860), True, 'import streamlit as st\n'), ((27868, 27896), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (27883, 27896), True, 'import streamlit as st\n'), ((27901, 27916), 'streamlit.write', 'st.write', (['reply'], {}), '(reply)\n', (27909, 27916), True, 'import streamlit as st\n'), ((27920, 27993), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'assistant', 'content': reply}"], {}), "({'role': 'assistant', 'content': reply})\n", (27952, 27993), True, 'import streamlit as st\n'), ((35827, 35859), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (35842, 35859), True, 'import streamlit as st\n'), ((35864, 35895), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (35875, 35895), True, 'import streamlit as st\n'), ((36265, 36293), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (36280, 36293), True, 'import streamlit as st\n'), ((36298, 36316), 'streamlit.markdown', 'st.markdown', (['reply'], {}), '(reply)\n', (36309, 36316), True, 'import streamlit as st\n'), ((36957, 36989), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (36972, 36989), True, 'import streamlit as st\n'), ((36994, 37025), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (37005, 37025), True, 'import streamlit as st\n'), ((37051, 37079), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (37064, 37079), True, 'import streamlit as st\n'), ((37121, 37190), 'streamlit.session_state.chat_msg.append', 'st.session_state.chat_msg.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (37153, 37190), True, 'import streamlit as st\n'), ((37597, 37682), 'streamlit.session_state.chat_msg.append', 'st.session_state.chat_msg.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content':\n full_response})\n", (37629, 37682), True, 'import streamlit as st\n'), ((37714, 37725), 'streamlit.error', 'st.error', (['e'], {}), '(e)\n', (37722, 37725), True, 'import streamlit as st\n'), ((42505, 42537), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (42520, 42537), True, 'import streamlit as st\n'), ((42542, 42573), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (42553, 42573), True, 'import streamlit as st\n'), ((42599, 42627), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (42612, 42627), True, 'import streamlit as st\n'), ((42668, 42732), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (42695, 42732), True, 'import streamlit as st\n'), ((43145, 43221), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content': full_response})\n", (43172, 43221), True, 'import streamlit as st\n'), ((43249, 43260), 'streamlit.error', 'st.error', (['e'], {}), '(e)\n', (43257, 43260), True, 'import streamlit as st\n'), ((56549, 56581), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (56564, 56581), True, 'import streamlit as st\n'), ((56586, 56617), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (56597, 56617), True, 'import streamlit as st\n'), ((56643, 56671), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (56656, 56671), True, 'import streamlit as st\n'), ((56713, 56777), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (56740, 56777), True, 'import streamlit as st\n'), ((57191, 57267), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content': full_response})\n", (57218, 57267), True, 'import streamlit as st\n'), ((57271, 57357), 'streamlit.session_state.memory.save_context', 'st.session_state.memory.save_context', (["{'input': prompt}", "{'output': full_response}"], {}), "({'input': prompt}, {'output':\n full_response})\n", (57307, 57357), True, 'import streamlit as st\n'), ((57389, 57400), 'streamlit.error', 'st.error', (['e'], {}), '(e)\n', (57397, 57400), True, 'import streamlit as st\n'), ((61119, 61146), 'os.path.splitext', 'os.path.splitext', (['file_name'], {}), '(file_name)\n', (61135, 61146), False, 'import os\n'), ((61571, 61632), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {'delete': '(False)', 'suffix': 'file_suffix'}), '(delete=False, suffix=file_suffix)\n', (61598, 61632), False, 'import tempfile\n'), ((62915, 62945), 'streamlit.write', 'st.write', (['docs[0].page_content'], {}), '(docs[0].page_content)\n', (62923, 62945), True, 'import streamlit as st\n'), ((67109, 67141), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (67124, 67141), True, 'import streamlit as st\n'), ((67146, 67177), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (67157, 67177), True, 'import streamlit as st\n'), ((67203, 67231), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (67216, 67231), True, 'import streamlit as st\n'), ((67859, 67923), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (67886, 67923), True, 'import streamlit as st\n'), ((68337, 68413), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content': full_response})\n", (68364, 68413), True, 'import streamlit as st\n'), ((68417, 68503), 'streamlit.session_state.memory.save_context', 'st.session_state.memory.save_context', (["{'input': prompt}", "{'output': full_response}"], {}), "({'input': prompt}, {'output':\n full_response})\n", (68453, 68503), True, 'import streamlit as st\n'), ((68536, 68547), 'streamlit.error', 'st.error', (['e'], {}), '(e)\n', (68544, 68547), True, 'import streamlit as st\n'), ((77320, 77352), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (77335, 77352), True, 'import streamlit as st\n'), ((77357, 77388), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (77368, 77388), True, 'import streamlit as st\n'), ((77414, 77442), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (77427, 77442), True, 'import streamlit as st\n'), ((78070, 78134), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (78097, 78134), True, 'import streamlit as st\n'), ((78548, 78624), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content': full_response})\n", (78575, 78624), True, 'import streamlit as st\n'), ((78628, 78714), 'streamlit.session_state.memory.save_context', 'st.session_state.memory.save_context', (["{'input': prompt}", "{'output': full_response}"], {}), "({'input': prompt}, {'output':\n full_response})\n", (78664, 78714), True, 'import streamlit as st\n'), ((78810, 78821), 'streamlit.error', 'st.error', (['e'], {}), '(e)\n', (78818, 78821), True, 'import streamlit as st\n'), ((82986, 83020), 'streamlit.chat_message', 'st.chat_message', (['avatars[msg.type]'], {}), '(avatars[msg.type])\n', (83001, 83020), True, 'import streamlit as st\n'), ((83326, 83347), 'streamlit.write', 'st.write', (['msg.content'], {}), '(msg.content)\n', (83334, 83347), True, 'import streamlit as st\n'), ((83576, 83610), 'langchain.tools.DuckDuckGoSearchRun', 'DuckDuckGoSearchRun', ([], {'name': '"""Search"""'}), "(name='Search')\n", (83595, 83610), False, 'from langchain.tools import DuckDuckGoSearchRun\n'), ((83873, 83901), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (83888, 83901), True, 'import streamlit as st\n'), ((84035, 84063), 'streamlit.write', 'st.write', (["response['output']"], {}), "(response['output'])\n", (84043, 84063), True, 'import streamlit as st\n'), ((87738, 87772), 'streamlit.chat_message', 'st.chat_message', (['avatars[msg.type]'], {}), '(avatars[msg.type])\n', (87753, 87772), True, 'import streamlit as st\n'), ((88078, 88099), 'streamlit.write', 'st.write', (['msg.content'], {}), '(msg.content)\n', (88086, 88099), True, 'import streamlit as st\n'), ((88345, 88388), 'langchain.tools.DuckDuckGoSearchRun', 'DuckDuckGoSearchRun', ([], {'name': '"""Internet Search"""'}), "(name='Internet Search')\n", (88364, 88388), False, 'from langchain.tools import DuckDuckGoSearchRun\n'), ((88651, 88679), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (88666, 88679), True, 'import streamlit as st\n'), ((88813, 88841), 'streamlit.write', 'st.write', (["response['output']"], {}), "(response['output'])\n", (88821, 88841), True, 'import streamlit as st\n'), ((92364, 92390), 'pandas.read_csv', 'pd.read_csv', (['uploaded_file'], {}), '(uploaded_file)\n', (92375, 92390), True, 'import pandas as pd\n'), ((8495, 8518), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (8510, 8518), True, 'import streamlit as st\n'), ((8524, 8543), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (8535, 8543), True, 'import streamlit as st\n'), ((8553, 8581), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (8568, 8581), True, 'import streamlit as st\n'), ((8609, 8619), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (8617, 8619), True, 'import streamlit as st\n'), ((8663, 8848), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': "st.session_state['openai_model']", 'messages': "[{'role': 'system', 'content': prompt_template}, {'role': 'user', 'content':\n prompt}]", 'stream': '(True)'}), "(model=st.session_state['openai_model'],\n messages=[{'role': 'system', 'content': prompt_template}, {'role':\n 'user', 'content': prompt}], stream=True)\n", (8691, 8848), False, 'import openai\n'), ((14099, 14133), 'streamlit.write', 'st.write', (['"""You are a female adult"""'], {}), "('You are a female adult')\n", (14107, 14133), True, 'import streamlit as st\n'), ((23840, 23863), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (23855, 23863), True, 'import streamlit as st\n'), ((23869, 23886), 'streamlit.write', 'st.write', (['message'], {}), '(message)\n', (23877, 23886), True, 'import streamlit as st\n'), ((23895, 23923), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (23910, 23923), True, 'import streamlit as st\n'), ((23929, 23976), 'streamlit.write', 'st.write', (['"""Hello human, what can I do for you?"""'], {}), "('Hello human, what can I do for you?')\n", (23937, 23976), True, 'import streamlit as st\n'), ((25312, 25335), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (25327, 25335), True, 'import streamlit as st\n'), ((36051, 36074), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (36066, 36074), True, 'import streamlit as st\n'), ((37199, 37222), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (37214, 37222), True, 'import streamlit as st\n'), ((37228, 37247), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (37239, 37247), True, 'import streamlit as st\n'), ((37257, 37285), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (37272, 37285), True, 'import streamlit as st\n'), ((37313, 37323), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (37321, 37323), True, 'import streamlit as st\n'), ((42741, 42764), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (42756, 42764), True, 'import streamlit as st\n'), ((42770, 42789), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (42781, 42789), True, 'import streamlit as st\n'), ((42799, 42827), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (42814, 42827), True, 'import streamlit as st\n'), ((42855, 42865), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (42863, 42865), True, 'import streamlit as st\n'), ((56786, 56809), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (56801, 56809), True, 'import streamlit as st\n'), ((56815, 56834), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (56826, 56834), True, 'import streamlit as st\n'), ((56844, 56872), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (56859, 56872), True, 'import streamlit as st\n'), ((56900, 56910), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (56908, 56910), True, 'import streamlit as st\n'), ((67303, 67357), 'streamlit.session_state.vectorstore.similarity_search', 'st.session_state.vectorstore.similarity_search', (['prompt'], {}), '(prompt)\n', (67349, 67357), True, 'import streamlit as st\n'), ((67932, 67955), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (67947, 67955), True, 'import streamlit as st\n'), ((67961, 67980), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (67972, 67980), True, 'import streamlit as st\n'), ((67990, 68018), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (68005, 68018), True, 'import streamlit as st\n'), ((68046, 68056), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (68054, 68056), True, 'import streamlit as st\n'), ((77514, 77568), 'streamlit.session_state.vectorstore.similarity_search', 'st.session_state.vectorstore.similarity_search', (['prompt'], {}), '(prompt)\n', (77560, 77568), True, 'import streamlit as st\n'), ((78143, 78166), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (78158, 78166), True, 'import streamlit as st\n'), ((78172, 78191), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (78183, 78191), True, 'import streamlit as st\n'), ((78201, 78229), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (78216, 78229), True, 'import streamlit as st\n'), ((78257, 78267), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (78265, 78267), True, 'import streamlit as st\n'), ((83425, 83448), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (83440, 83448), True, 'import streamlit as st\n'), ((83939, 83953), 'streamlit.container', 'st.container', ([], {}), '()\n', (83951, 83953), True, 'import streamlit as st\n'), ((88177, 88200), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (88192, 88200), True, 'import streamlit as st\n'), ((88717, 88731), 'streamlit.container', 'st.container', ([], {}), '()\n', (88729, 88731), True, 'import streamlit as st\n'), ((92447, 92502), 'streamlit.write', 'st.write', (['"""There was an error processing the CSV file."""'], {}), "('There was an error processing the CSV file.')\n", (92455, 92502), True, 'import streamlit as st\n'), ((92506, 92517), 'streamlit.write', 'st.write', (['e'], {}), '(e)\n', (92514, 92517), True, 'import streamlit as st\n'), ((93337, 93349), 'streamlit.spinner', 'st.spinner', ([], {}), '()\n', (93347, 93349), True, 'import streamlit as st\n'), ((93361, 93406), 'pandasai.llm.openai.OpenAI', 'OpenAI', ([], {'api_token': 'st.session_state.openai_key'}), '(api_token=st.session_state.openai_key)\n', (93367, 93406), False, 'from pandasai.llm.openai import OpenAI\n'), ((93416, 93546), 'pandasai.SmartDataframe', 'SmartDataframe', (['st.session_state.df'], {'config': "{'llm': llm, 'save_charts_path': chart_path, 'save_charts': True, 'verbose':\n True}"}), "(st.session_state.df, config={'llm': llm, 'save_charts_path':\n chart_path, 'save_charts': True, 'verbose': True})\n", (93430, 93546), False, 'from pandasai import SmartDataframe\n'), ((93785, 93833), 'os.path.join', 'os.path.join', (['"""exports/charts"""', '"""temp_chart.png"""'], {}), "('exports/charts', 'temp_chart.png')\n", (93797, 93833), False, 'import os\n'), ((93841, 93867), 'os.path.exists', 'os.path.exists', (['chart_path'], {}), '(chart_path)\n', (93855, 93867), False, 'import os\n'), ((94004, 94052), 'streamlit.session_state.prompt_history.append', 'st.session_state.prompt_history.append', (['question'], {}), '(question)\n', (94042, 94052), True, 'import streamlit as st\n'), ((14184, 14216), 'streamlit.write', 'st.write', (['"""You are a young girl"""'], {}), "('You are a young girl')\n", (14192, 14216), True, 'import streamlit as st\n'), ((83188, 83260), 'streamlit.status', 'st.status', (['f"""**{step[0].tool}**: {step[0].tool_input}"""'], {'state': '"""complete"""'}), "(f'**{step[0].tool}**: {step[0].tool_input}', state='complete')\n", (83197, 83260), True, 'import streamlit as st\n'), ((83278, 83299), 'streamlit.write', 'st.write', (['step[0].log'], {}), '(step[0].log)\n', (83286, 83299), True, 'import streamlit as st\n'), ((83305, 83322), 'streamlit.write', 'st.write', (['step[1]'], {}), '(step[1])\n', (83313, 83322), True, 'import streamlit as st\n'), ((87940, 88012), 'streamlit.status', 'st.status', (['f"""**{step[0].tool}**: {step[0].tool_input}"""'], {'state': '"""complete"""'}), "(f'**{step[0].tool}**: {step[0].tool_input}', state='complete')\n", (87949, 88012), True, 'import streamlit as st\n'), ((88030, 88051), 'streamlit.write', 'st.write', (['step[0].log'], {}), '(step[0].log)\n', (88038, 88051), True, 'import streamlit as st\n'), ((88057, 88074), 'streamlit.write', 'st.write', (['step[1]'], {}), '(step[1])\n', (88065, 88074), True, 'import streamlit as st\n'), ((93749, 93767), 'streamlit.write', 'st.write', (['response'], {}), '(response)\n', (93757, 93767), True, 'import streamlit as st\n'), ((93874, 93944), 'streamlit.image', 'st.image', (['chart_path'], {'caption': '"""Generated Chart"""', 'use_column_width': '(True)'}), "(chart_path, caption='Generated Chart', use_column_width=True)\n", (93882, 93944), True, 'import streamlit as st\n')] |
import argparse
import duckdb
import lancedb
import pyarrow.compute as pc
from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast
import gradio as gr
MODEL_ID = None
MODEL = None
TOKENIZER = None
PROCESSOR = None
def get_table():
db = lancedb.connect("data/video-lancedb")
return db.open_table("multimodal_video")
def setup_clip_model(model_id):
global MODEL_ID, MODEL, TOKENIZER, PROCESSOR
MODEL_ID = model_id
TOKENIZER = CLIPTokenizerFast.from_pretrained(MODEL_ID)
MODEL = CLIPModel.from_pretrained(MODEL_ID)
PROCESSOR = CLIPProcessor.from_pretrained(MODEL_ID)
def embed_func(query):
inputs = TOKENIZER([query], padding=True, return_tensors="pt")
text_features = MODEL.get_text_features(**inputs)
return text_features.detach().numpy()[0]
def find_video_vectors(query):
emb = embed_func(query)
code = (
"import lancedb\n"
"db = lancedb.connect('data/video-lancedb')\n"
"tbl = db.open_table('multimodal_video')\n\n"
f"embedding = embed_func('{query}')\n"
"tbl.search(embedding).limit(9).to_df()"
)
return (_extract(tbl.search(emb).limit(9).to_df()), code)
def find_video_keywords(query):
code = (
"import lancedb\n"
"db = lancedb.connect('data/video-lancedb')\n"
"tbl = db.open_table('multimodal_video')\n\n"
f"tbl.search('{query}').limit(9).to_df()"
)
return (_extract(tbl.search(query).limit(9).to_df()), code)
def find_video_sql(query):
code = (
"import lancedb\n"
"import duckdb\n"
"db = lancedb.connect('data/video-lancedb')\n"
"tbl = db.open_table('multimodal_video')\n\n"
"videos = tbl.to_lance()\n"
f"duckdb.sql('{query}').to_df()"
)
videos = tbl.to_lance()
return (_extract(duckdb.sql(query).to_df()), code)
def _extract(df): # Define a 3x3 Python list to store the HTML code
video_id_col = "video_id"
start_time_col = "start_time"
grid_html = '<div style="display: grid; grid-template-columns: repeat(3, 1fr); grid-gap: 20px;">'
for _, row in df.iterrows():
iframe_code = f'<iframe width="100%" height="315" src="https://www.youtube.com/embed/{row[video_id_col]}?start={str(row[start_time_col])}" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>'
grid_html += f'<div style="width: 100%;">{iframe_code}</div>'
grid_html += "</div>"
return grid_html
def create_gradio_dash():
with gr.Blocks() as demo:
gr.Markdown(
"""
# Multimodal Video Search with LanceDB
We used LanceDB to store frames every thirty seconds and the title of 13000+ videos, 5 random from each top category from the Youtube 8M dataset.
Then, we used the CLIP model to embed frames and titles together. With LanceDB, we can perform embedding, keyword, and SQL search on these videos.
"""
)
with gr.Row():
with gr.Tab("Embeddings"):
vector_query = gr.Textbox(value="retro gaming", show_label=False)
b1 = gr.Button("Submit")
with gr.Tab("Keywords"):
keyword_query = gr.Textbox(value="ninja turtles", show_label=False)
b2 = gr.Button("Submit")
with gr.Tab("SQL"):
sql_query = gr.Textbox(
value="SELECT DISTINCT video_id, * from videos WHERE start_time > 0 LIMIT 9",
show_label=False,
)
b3 = gr.Button("Submit")
with gr.Row():
code = gr.Code(label="Code", language="python")
with gr.Row():
gallery = gr.HTML()
b1.click(find_video_vectors, inputs=vector_query, outputs=[gallery, code])
b2.click(find_video_keywords, inputs=keyword_query, outputs=[gallery, code])
b3.click(find_video_sql, inputs=sql_query, outputs=[gallery, code])
demo.launch()
def args_parse():
parser = argparse.ArgumentParser()
parser.add_argument("--model_id", type=str, default="openai/clip-vit-base-patch32")
return parser.parse_args()
if __name__ == "__main__":
args = args_parse()
setup_clip_model(args.model_id)
tbl = get_table()
create_gradio_dash()
| [
"lancedb.connect"
] | [((255, 292), 'lancedb.connect', 'lancedb.connect', (['"""data/video-lancedb"""'], {}), "('data/video-lancedb')\n", (270, 292), False, 'import lancedb\n'), ((461, 504), 'transformers.CLIPTokenizerFast.from_pretrained', 'CLIPTokenizerFast.from_pretrained', (['MODEL_ID'], {}), '(MODEL_ID)\n', (494, 504), False, 'from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast\n'), ((517, 552), 'transformers.CLIPModel.from_pretrained', 'CLIPModel.from_pretrained', (['MODEL_ID'], {}), '(MODEL_ID)\n', (542, 552), False, 'from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast\n'), ((569, 608), 'transformers.CLIPProcessor.from_pretrained', 'CLIPProcessor.from_pretrained', (['MODEL_ID'], {}), '(MODEL_ID)\n', (598, 608), False, 'from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast\n'), ((4123, 4148), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (4146, 4148), False, 'import argparse\n'), ((2589, 2600), 'gradio.Blocks', 'gr.Blocks', ([], {}), '()\n', (2598, 2600), True, 'import gradio as gr\n'), ((2618, 3061), 'gradio.Markdown', 'gr.Markdown', (['"""\n # Multimodal Video Search with LanceDB\n We used LanceDB to store frames every thirty seconds and the title of 13000+ videos, 5 random from each top category from the Youtube 8M dataset. \n Then, we used the CLIP model to embed frames and titles together. With LanceDB, we can perform embedding, keyword, and SQL search on these videos.\n """'], {}), '(\n """\n # Multimodal Video Search with LanceDB\n We used LanceDB to store frames every thirty seconds and the title of 13000+ videos, 5 random from each top category from the Youtube 8M dataset. \n Then, we used the CLIP model to embed frames and titles together. With LanceDB, we can perform embedding, keyword, and SQL search on these videos.\n """\n )\n', (2629, 3061), True, 'import gradio as gr\n'), ((3087, 3095), 'gradio.Row', 'gr.Row', ([], {}), '()\n', (3093, 3095), True, 'import gradio as gr\n'), ((3701, 3709), 'gradio.Row', 'gr.Row', ([], {}), '()\n', (3707, 3709), True, 'import gradio as gr\n'), ((3730, 3770), 'gradio.Code', 'gr.Code', ([], {'label': '"""Code"""', 'language': '"""python"""'}), "(label='Code', language='python')\n", (3737, 3770), True, 'import gradio as gr\n'), ((3784, 3792), 'gradio.Row', 'gr.Row', ([], {}), '()\n', (3790, 3792), True, 'import gradio as gr\n'), ((3816, 3825), 'gradio.HTML', 'gr.HTML', ([], {}), '()\n', (3823, 3825), True, 'import gradio as gr\n'), ((3114, 3134), 'gradio.Tab', 'gr.Tab', (['"""Embeddings"""'], {}), "('Embeddings')\n", (3120, 3134), True, 'import gradio as gr\n'), ((3167, 3217), 'gradio.Textbox', 'gr.Textbox', ([], {'value': '"""retro gaming"""', 'show_label': '(False)'}), "(value='retro gaming', show_label=False)\n", (3177, 3217), True, 'import gradio as gr\n'), ((3239, 3258), 'gradio.Button', 'gr.Button', (['"""Submit"""'], {}), "('Submit')\n", (3248, 3258), True, 'import gradio as gr\n'), ((3276, 3294), 'gradio.Tab', 'gr.Tab', (['"""Keywords"""'], {}), "('Keywords')\n", (3282, 3294), True, 'import gradio as gr\n'), ((3328, 3379), 'gradio.Textbox', 'gr.Textbox', ([], {'value': '"""ninja turtles"""', 'show_label': '(False)'}), "(value='ninja turtles', show_label=False)\n", (3338, 3379), True, 'import gradio as gr\n'), ((3401, 3420), 'gradio.Button', 'gr.Button', (['"""Submit"""'], {}), "('Submit')\n", (3410, 3420), True, 'import gradio as gr\n'), ((3438, 3451), 'gradio.Tab', 'gr.Tab', (['"""SQL"""'], {}), "('SQL')\n", (3444, 3451), True, 'import gradio as gr\n'), ((3481, 3596), 'gradio.Textbox', 'gr.Textbox', ([], {'value': '"""SELECT DISTINCT video_id, * from videos WHERE start_time > 0 LIMIT 9"""', 'show_label': '(False)'}), "(value=\n 'SELECT DISTINCT video_id, * from videos WHERE start_time > 0 LIMIT 9',\n show_label=False)\n", (3491, 3596), True, 'import gradio as gr\n'), ((3668, 3687), 'gradio.Button', 'gr.Button', (['"""Submit"""'], {}), "('Submit')\n", (3677, 3687), True, 'import gradio as gr\n'), ((1813, 1830), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (1823, 1830), False, 'import duckdb\n')] |
# %% [markdown]
# # Code documentation Q&A bot example with LangChain
#
# This Q&A bot will allow you to query your own documentation easily using questions. We'll also demonstrate the use of LangChain and LanceDB using the OpenAI API.
#
# In this example we'll use Pandas 2.0 documentation, but, this could be replaced for your own docs as well
import os
import openai
import argparse
import lancedb
import re
import pickle
import requests
import zipfile
from pathlib import Path
from langchain.document_loaders import BSHTMLLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import LanceDB
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
def get_document_title(document):
m = str(document.metadata["source"])
title = re.findall("pandas.documentation(.*).html", m)
if title[0] is not None:
return title[0]
return ""
def arg_parse():
default_query = "What are the major differences in pandas 2.0?"
parser = argparse.ArgumentParser(description="Code Documentation QA Bot")
parser.add_argument(
"--query", type=str, default=default_query, help="query to search"
)
parser.add_argument("--openai-key", type=str, help="OpenAI API Key")
args = parser.parse_args()
if not args.openai_key:
if "OPENAI_API_KEY" not in os.environ:
raise ValueError(
"OPENAI_API_KEY environment variable not set. Please set it or pass --openai_key"
)
else:
openai.api_key = args.openai_key
return args
if __name__ == "__main__":
args = arg_parse()
docs_path = Path("docs.pkl")
docs = []
pandas_docs = requests.get(
"https://eto-public.s3.us-west-2.amazonaws.com/datasets/pandas_docs/pandas.documentation.zip"
)
with open("/tmp/pandas.documentation.zip", "wb") as f:
f.write(pandas_docs.content)
file = zipfile.ZipFile("/tmp/pandas.documentation.zip")
file.extractall(path="/tmp/pandas_docs")
if not docs_path.exists():
for p in Path("/tmp/pandas_docs/pandas.documentation").rglob("*.html"):
print(p)
if p.is_dir():
continue
loader = BSHTMLLoader(p, open_encoding="utf8")
raw_document = loader.load()
m = {}
m["title"] = get_document_title(raw_document[0])
m["version"] = "2.0rc0"
raw_document[0].metadata = raw_document[0].metadata | m
raw_document[0].metadata["source"] = str(raw_document[0].metadata["source"])
docs = docs + raw_document
with docs_path.open("wb") as fh:
pickle.dump(docs, fh)
else:
with docs_path.open("rb") as fh:
docs = pickle.load(fh)
print("Loaded {} documents".format(len(docs)))
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200,
)
documents = text_splitter.split_documents(docs)
embeddings = OpenAIEmbeddings()
db = lancedb.connect("/tmp/lancedb")
table = db.create_table(
"pandas_docs",
data=[
{
"vector": embeddings.embed_query("Hello World"),
"text": "Hello World",
"id": "1",
}
],
mode="overwrite",
)
docsearch = LanceDB.from_documents(documents, embeddings, connection=table)
qa = RetrievalQA.from_chain_type(
llm=OpenAI(), chain_type="stuff", retriever=docsearch.as_retriever()
)
result = qa.run(args.query)
print(result)
| [
"lancedb.connect"
] | [((859, 905), 're.findall', 're.findall', (['"""pandas.documentation(.*).html"""', 'm'], {}), "('pandas.documentation(.*).html', m)\n", (869, 905), False, 'import re\n'), ((1074, 1138), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Code Documentation QA Bot"""'}), "(description='Code Documentation QA Bot')\n", (1097, 1138), False, 'import argparse\n'), ((1704, 1720), 'pathlib.Path', 'Path', (['"""docs.pkl"""'], {}), "('docs.pkl')\n", (1708, 1720), False, 'from pathlib import Path\n'), ((1754, 1871), 'requests.get', 'requests.get', (['"""https://eto-public.s3.us-west-2.amazonaws.com/datasets/pandas_docs/pandas.documentation.zip"""'], {}), "(\n 'https://eto-public.s3.us-west-2.amazonaws.com/datasets/pandas_docs/pandas.documentation.zip'\n )\n", (1766, 1871), False, 'import requests\n'), ((1984, 2032), 'zipfile.ZipFile', 'zipfile.ZipFile', (['"""/tmp/pandas.documentation.zip"""'], {}), "('/tmp/pandas.documentation.zip')\n", (1999, 2032), False, 'import zipfile\n'), ((2909, 2975), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(200)'}), '(chunk_size=1000, chunk_overlap=200)\n', (2939, 2975), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((3068, 3086), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (3084, 3086), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((3097, 3128), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (3112, 3128), False, 'import lancedb\n'), ((3414, 3477), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['documents', 'embeddings'], {'connection': 'table'}), '(documents, embeddings, connection=table)\n', (3436, 3477), False, 'from langchain.vectorstores import LanceDB\n'), ((2284, 2321), 'langchain.document_loaders.BSHTMLLoader', 'BSHTMLLoader', (['p'], {'open_encoding': '"""utf8"""'}), "(p, open_encoding='utf8')\n", (2296, 2321), False, 'from langchain.document_loaders import BSHTMLLoader\n'), ((2730, 2751), 'pickle.dump', 'pickle.dump', (['docs', 'fh'], {}), '(docs, fh)\n', (2741, 2751), False, 'import pickle\n'), ((2822, 2837), 'pickle.load', 'pickle.load', (['fh'], {}), '(fh)\n', (2833, 2837), False, 'import pickle\n'), ((3529, 3537), 'langchain.llms.OpenAI', 'OpenAI', ([], {}), '()\n', (3535, 3537), False, 'from langchain.llms import OpenAI\n'), ((2127, 2172), 'pathlib.Path', 'Path', (['"""/tmp/pandas_docs/pandas.documentation"""'], {}), "('/tmp/pandas_docs/pandas.documentation')\n", (2131, 2172), False, 'from pathlib import Path\n')] |
from langchain.vectorstores.lancedb import LanceDB
import lancedb
from .embedding.base import BaseEmbedding
from .base import VectorStore
class LanceDBVectorStore(VectorStore):
def __init__(self, index_name: str, db_path: str, embeddings: BaseEmbedding, api_key: str | None = None):
self.db = lancedb.connect(db_path, api_key=api_key)
if index_name not in self.db.table_names():
self.table = self.db.create_table(
name=index_name,
data=[{
"id": "1",
"text": "Hello World",
"vector": embeddings.client.embed_query("Hello World"),
}],
mode="overwrite",
)
else:
self.table = self.db.open_table(index_name)
self.embeddings = embeddings
self.client = LanceDB(connection=self.table,
embedding=embeddings.client)
| [
"lancedb.connect"
] | [((309, 350), 'lancedb.connect', 'lancedb.connect', (['db_path'], {'api_key': 'api_key'}), '(db_path, api_key=api_key)\n', (324, 350), False, 'import lancedb\n'), ((854, 913), 'langchain.vectorstores.lancedb.LanceDB', 'LanceDB', ([], {'connection': 'self.table', 'embedding': 'embeddings.client'}), '(connection=self.table, embedding=embeddings.client)\n', (861, 913), False, 'from langchain.vectorstores.lancedb import LanceDB\n')] |
import os
import glob
import tqdm
import pathtrees as pt
import numpy as np
import pandas as pd
import lancedb
import matplotlib.pyplot as plt
from .step_annotations import load_object_annotations_from_csvs, get_obj_ann
from IPython import embed
from ..config import get_cfg
# def load_object_annotations(meta_csv, states_csv):
# meta_df = pd.read_csv(meta_csv).set_index('video_name').groupby(level=0).last()
# object_names = []
# for c in meta_df.columns:
# if c.startswith('#'):
# meta_df[c[1:]] = meta_df.pop(c).fillna('').apply(lambda s: [int(float(x)) for x in str(s).split('+') if x != ''])
# object_names.append(c[1:])
# states_df = pd.read_csv(states_csv)
# states_df = states_df[states_df.time.fillna('') != '']
# # print(states_df.shape)
# print(set(states_df.video_name.unique()) - set(meta_df.index.unique()))
# states_df = states_df[states_df.video_name.isin(meta_df.index.unique())]
# states_df['time'] = pd.to_timedelta(states_df.time.apply(lambda x: f'00:{x}'))
# states_df['start_frame'] = (states_df.time.dt.total_seconds() * meta_df.fps.loc[states_df.video_name].values).astype(int)
# # print(states_df.shape)
# # creating a dict of {video_id: {track_id: df}}
# dfs = {}
# for vid, row in meta_df.iterrows():
# objs = {}
# sdf = states_df[states_df.video_name == vid]
# for c in object_names:
# if c not in sdf.columns:
# continue
# odf = sdf[[c, 'start_frame']].copy().rename(columns={c: "state"})
# odf = odf[odf.state.fillna('') != '']
# odf = odf.drop_duplicates(subset=['start_frame'], keep='last')
# odf['stop_frame'] = odf['start_frame'].shift(-1)
# odf['object'] = c
# if not len(odf):
# continue
# track_id=None
# for track_id in row[c]:
# objs[track_id] = odf
# print(vid, track_id, odf.shape)
# dfs[vid] = objs
# return dfs
def get_obj_anns(dfs, frame_idx):
idxs = []
for i in frame_idx:
ds = {
k: df[(df.start_frame <= i) & (pd.isna(df.stop_frame) | (df.stop_frame > i))]
for k, df in dfs.items()
}
obj = list(set(d.object.iloc[0] for d in ds.values() if len(d)))
assert len(obj) < 2, f"Something is wrong.. disagreeing labels ({obj}) assigned to object track"
idxs.append({
**{f'{k}_state': d.state.iloc[-1] for k, d in ds.items() if len(d)},
'object': obj[0],
} if obj else {})
return pd.DataFrame(idxs)
def load_data(cfg, data_file_pattern, use_aug=True, data_slice=None):
'''Load npz files (one per video) with embedding and label keys and concatenate
'''
embeddings_list, df_list = [], []
dfs = {
k: load_object_annotations_from_csvs(cfg.DATASET.META_CSV, f)
for k, f in cfg.DATASET.STATES_CSVS.items()
}
# embed()
fs = glob.glob(data_file_pattern) if not isinstance(data_file_pattern, list) else data_file_pattern
print(f"Found {len(fs)} files", fs[:1])
for f in tqdm.tqdm(fs, desc='loading data...'):
# print(f)
# if 'pinwheels' not in f and 'quesadilla' not in f: continue
# if 'plain' not in f:
# print(f)
# continue
data = np.load(f)
z = data['z'].astype(np.float32)
z = z / np.linalg.norm(z, axis=-1, keepdims=True)
frame_idx = data['frame_index']
# maybe filter out augmentations
augmented = data.get('augmented')
if augmented is None:
augmented = np.zeros(len(z), dtype=bool)
if not use_aug:
z = z[~augmented]
frame_idx = frame_idx[~augmented]
# get video ID and track ID
video_id = data.get('video_name')
if video_id is None:
video_id = f.split('/')[-3]
else:
video_id = video_id.item()
video_id = os.path.splitext(video_id)[0]
track_id = data.get('track_id')
if track_id is None:
track_id = f.split('/')[-1].split('.')[0]
else:
track_id = track_id.item()
track_id = int(track_id)
dfsi = {k: df[video_id][track_id] for k, df in dfs.items() if video_id in df and track_id in df[video_id]}
for k in dfsi:
tqdm.tqdm.write(f"{k} {set(dfs[k])&{video_id}}")
if video_id in dfs[k]:
tqdm.tqdm.write(f"{k} {set(dfs[k][video_id])&{track_id}}")
if not dfsi:
tqdm.tqdm.write(f"Skipping: {video_id}: {track_id}")
continue
# tqdm.tqdm.write(f"Using: {video_id}: {track_id}")
# get object state annotations
ann = get_obj_anns(dfsi, frame_idx)
if not all(ann.shape):
tqdm.tqdm.write(f"no data for {video_id}.{track_id} {ann.shape} {z.shape}")
for k in dfs:
tqdm.tqdm.write(f"{k} {set(dfs[k])&{video_id}}")
continue
tqdm.tqdm.write(f"using {video_id}.{track_id} {ann.shape} {set(dfsi)} {z.shape}")
embeddings_list.append(z)
df_list.append(pd.DataFrame({
'index': frame_idx,
'object': ann.object,
**{k: ann[k] for k in ann.columns if k.endswith('_state')},
'track_id': track_id,
'video_id': video_id,
'augmented': augmented,
}))
# break
df = pd.concat(df_list)
df['vector'] = [x for xs in embeddings_list for x in xs]
return df
def cluster_reduce(data, y, n_clusters=200, n_pts_per_cluster=20, n_clusters_per_class=10):
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
embed()
data = data[y=='peanut-butter']
y=y[y=='peanut-butter']
# Step 0: Normalization
scaler = StandardScaler()
data = scaler.fit_transform(data)
# Step 1: PCA
print(data.shape)
pca = PCA(n_components=30) # Choose the number of components based on your data
data_pca = pca.fit_transform(data)
print(data_pca.shape)
plt.figure(figsize=(15, 15))
for yi in np.unique(y):
plt.scatter(data_pca[y==yi, 0], data_pca[y==yi, 1], label=yi)
plt.legend()
plt.savefig("PCA.png")
plt.close()
# Perform k-means clustering
_, inv, counts = np.unique(y, return_inverse=True, return_counts=True)
p = 1 / counts[inv]
p = p / p.sum()
n = n_clusters * n_pts_per_cluster * 10
if n < len(y):
idxs = np.random.choice(len(y), n, p=p, replace=False)
np.sort(idxs)
data = data[idxs]
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
kmeans.fit(data_pca)
clusters = kmeans.labels_
# unique, count = np.unique(labels, return_counts=True)
# for c, u in sorted(zip(count, unique)):
# print(u, c)
# Sample a fixed number of points from each cluster
sampled_points = []
cluster_indices = {}
for i in np.unique(clusters):
indices = np.where(clusters == i)[0]
y_counts = pd.Series(y[indices]).value_counts()
y_top = y_counts.index[0]
cluster_indices.setdefault(y_top, []).append((i, y_counts, indices))
sampled_points = []
for y_top, xs in cluster_indices.items():
print(y_top, len(xs))
xs = sorted(xs, key=lambda x: (x[1]/x[1].sum()).iloc[0], reverse=True)
for (i, c, indices) in xs[:n_clusters_per_class]:
print(i, c)
sampled_points.extend(indices)
# print(i, len(indices), pd.Series(y[indices]).value_counts().iloc[:2].to_dict())
# if len(indices) > n_pts_per_cluster:
# indices = np.random.choice(indices, n_pts_per_cluster, replace=False)
# sampled_points.extend(indices)
return np.array(sorted(sampled_points))
def dump_db(db_fname, df):
db = lancedb.connect(db_fname)
table_names = db.table_names()
# ---------------------- Write out table for each object --------------------- #
for object_name, odf in tqdm.tqdm(df.groupby('object')):
# if object_name != 'tortilla': continue
if object_name in table_names:
# if not overwrite:
# print("table", object_name, 'exists')
# return
db.drop_table(object_name)
print(object_name, len(odf))
print(odf.describe())
# idx = cluster_reduce(np.array(list(odf.vector.values)), odf.super_simple_state.values)
# odf = odf.iloc[idx]
# print(odf.describe())
tbl = db.create_table(object_name, data=odf)#.iloc[idx]
def fix_vocab(sdf):
RENAME = {
'[partial]': '',
'[full]': '',
'floss-underneath': 'ends-cut',
'floss-crossed': 'ends-cut',
'raisins[cooked]': 'raisins',
'oatmeal[cooked]+raisins': 'oatmeal+raisins',
'teabag': 'tea-bag',
'+stirrer': '',
'[stirred]': '',
'water+honey': 'water',
'with-quesadilla': 'with-food',
'with-pinwheels': 'with-food',
}
sdf['mod_state'] = sdf.full_state.copy()
for old, new in RENAME.items():
sdf['mod_state'] = sdf.mod_state.str.replace(old, new)
sdf = sdf[~sdf.mod_state.isin(['folding', 'rolling', 'oatmeal+raisins+cinnamon', 'oatmeal+raisins+cinnamon+honey', 'on-plate'])]
sdf.groupby('object').mod_state.value_counts()
sdf['super_simple_state'] = sdf['mod_state']
return sdf
import ipdb
@ipdb.iex
def build(config_name, embeddings_dir='embeddings', overwrite=False):
cfg = get_cfg(config_name)
tree = pt.tree(cfg.DATASET.ROOT, {
'{embeddings_dir}/{field_name}/{video_id}/{emb_type}/{track_id}.npz': 'emb_file',
'{emb_type}.lancedb': 'db_fname',
}).specify(embeddings_dir=embeddings_dir)
# emb_dir = os.path.join(cfg.DATASET.ROOT, 'embeddings1', cfg.EVAL.DETECTION_NAME)
# emb_types = cfg.EVAL.EMBEDDING_TYPES
for emb_type in ['clip']: #emb_types:
# ---------------------- Load the embeddings and states ---------------------- #
data_file_pattern = tree.emb_file.specify(emb_type=emb_type).glob_format() #f'{emb_dir}/*/{emb_type}/*.npz'
df = load_data(cfg, data_file_pattern)
df = fix_vocab(df)
# ----------------------------- Open the database ---------------------------- #
# db_fname = os.path.join(cfg.DATASET.ROOT, f'{cfg.EVAL.DETECTION_NAME}_{emb_type}.lancedb')
db_fname = tree.db_fname.format(emb_type=emb_type)
dump_db(db_fname, df)
def vis(db_fname):
db = lancedb.connect(db_fname)
for name in db.table_names():
print(name)
df = db[name].to_pandas()
print(df.describe(include='all'))
embed()
if __name__ == '__main__':
import fire
fire.Fire() | [
"lancedb.connect"
] | [((2658, 2676), 'pandas.DataFrame', 'pd.DataFrame', (['idxs'], {}), '(idxs)\n', (2670, 2676), True, 'import pandas as pd\n'), ((3211, 3248), 'tqdm.tqdm', 'tqdm.tqdm', (['fs'], {'desc': '"""loading data..."""'}), "(fs, desc='loading data...')\n", (3220, 3248), False, 'import tqdm\n'), ((5542, 5560), 'pandas.concat', 'pd.concat', (['df_list'], {}), '(df_list)\n', (5551, 5560), True, 'import pandas as pd\n'), ((5869, 5876), 'IPython.embed', 'embed', ([], {}), '()\n', (5874, 5876), False, 'from IPython import embed\n'), ((5982, 5998), 'sklearn.preprocessing.StandardScaler', 'StandardScaler', ([], {}), '()\n', (5996, 5998), False, 'from sklearn.preprocessing import StandardScaler\n'), ((6088, 6108), 'sklearn.decomposition.PCA', 'PCA', ([], {'n_components': '(30)'}), '(n_components=30)\n', (6091, 6108), False, 'from sklearn.decomposition import PCA\n'), ((6233, 6261), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(15, 15)'}), '(figsize=(15, 15))\n', (6243, 6261), True, 'import matplotlib.pyplot as plt\n'), ((6276, 6288), 'numpy.unique', 'np.unique', (['y'], {}), '(y)\n', (6285, 6288), True, 'import numpy as np\n'), ((6364, 6376), 'matplotlib.pyplot.legend', 'plt.legend', ([], {}), '()\n', (6374, 6376), True, 'import matplotlib.pyplot as plt\n'), ((6381, 6403), 'matplotlib.pyplot.savefig', 'plt.savefig', (['"""PCA.png"""'], {}), "('PCA.png')\n", (6392, 6403), True, 'import matplotlib.pyplot as plt\n'), ((6408, 6419), 'matplotlib.pyplot.close', 'plt.close', ([], {}), '()\n', (6417, 6419), True, 'import matplotlib.pyplot as plt\n'), ((6475, 6528), 'numpy.unique', 'np.unique', (['y'], {'return_inverse': '(True)', 'return_counts': '(True)'}), '(y, return_inverse=True, return_counts=True)\n', (6484, 6528), True, 'import numpy as np\n'), ((6760, 6806), 'sklearn.cluster.KMeans', 'KMeans', ([], {'n_clusters': 'n_clusters', 'random_state': '(42)'}), '(n_clusters=n_clusters, random_state=42)\n', (6766, 6806), False, 'from sklearn.cluster import KMeans\n'), ((7109, 7128), 'numpy.unique', 'np.unique', (['clusters'], {}), '(clusters)\n', (7118, 7128), True, 'import numpy as np\n'), ((7991, 8016), 'lancedb.connect', 'lancedb.connect', (['db_fname'], {}), '(db_fname)\n', (8006, 8016), False, 'import lancedb\n'), ((10675, 10700), 'lancedb.connect', 'lancedb.connect', (['db_fname'], {}), '(db_fname)\n', (10690, 10700), False, 'import lancedb\n'), ((10835, 10842), 'IPython.embed', 'embed', ([], {}), '()\n', (10840, 10842), False, 'from IPython import embed\n'), ((10891, 10902), 'fire.Fire', 'fire.Fire', ([], {}), '()\n', (10900, 10902), False, 'import fire\n'), ((3059, 3087), 'glob.glob', 'glob.glob', (['data_file_pattern'], {}), '(data_file_pattern)\n', (3068, 3087), False, 'import glob\n'), ((3432, 3442), 'numpy.load', 'np.load', (['f'], {}), '(f)\n', (3439, 3442), True, 'import numpy as np\n'), ((6298, 6363), 'matplotlib.pyplot.scatter', 'plt.scatter', (['data_pca[y == yi, 0]', 'data_pca[y == yi, 1]'], {'label': 'yi'}), '(data_pca[y == yi, 0], data_pca[y == yi, 1], label=yi)\n', (6309, 6363), True, 'import matplotlib.pyplot as plt\n'), ((6707, 6720), 'numpy.sort', 'np.sort', (['idxs'], {}), '(idxs)\n', (6714, 6720), True, 'import numpy as np\n'), ((3500, 3541), 'numpy.linalg.norm', 'np.linalg.norm', (['z'], {'axis': '(-1)', 'keepdims': '(True)'}), '(z, axis=-1, keepdims=True)\n', (3514, 3541), True, 'import numpy as np\n'), ((4069, 4095), 'os.path.splitext', 'os.path.splitext', (['video_id'], {}), '(video_id)\n', (4085, 4095), False, 'import os\n'), ((4651, 4703), 'tqdm.tqdm.write', 'tqdm.tqdm.write', (['f"""Skipping: {video_id}: {track_id}"""'], {}), "(f'Skipping: {video_id}: {track_id}')\n", (4666, 4703), False, 'import tqdm\n'), ((4912, 4987), 'tqdm.tqdm.write', 'tqdm.tqdm.write', (['f"""no data for {video_id}.{track_id} {ann.shape} {z.shape}"""'], {}), "(f'no data for {video_id}.{track_id} {ann.shape} {z.shape}')\n", (4927, 4987), False, 'import tqdm\n'), ((7148, 7171), 'numpy.where', 'np.where', (['(clusters == i)'], {}), '(clusters == i)\n', (7156, 7171), True, 'import numpy as np\n'), ((9707, 9859), 'pathtrees.tree', 'pt.tree', (['cfg.DATASET.ROOT', "{'{embeddings_dir}/{field_name}/{video_id}/{emb_type}/{track_id}.npz':\n 'emb_file', '{emb_type}.lancedb': 'db_fname'}"], {}), "(cfg.DATASET.ROOT, {\n '{embeddings_dir}/{field_name}/{video_id}/{emb_type}/{track_id}.npz':\n 'emb_file', '{emb_type}.lancedb': 'db_fname'})\n", (9714, 9859), True, 'import pathtrees as pt\n'), ((7194, 7215), 'pandas.Series', 'pd.Series', (['y[indices]'], {}), '(y[indices])\n', (7203, 7215), True, 'import pandas as pd\n'), ((2203, 2225), 'pandas.isna', 'pd.isna', (['df.stop_frame'], {}), '(df.stop_frame)\n', (2210, 2225), True, 'import pandas as pd\n')] |
## Imports:
import os
from langchain.chat_models import ChatOpenAI
from langchain.tools import WikipediaQueryRun
from langchain.utilities import WikipediaAPIWrapper
from langchain.tools import DuckDuckGoSearchRun
from langchain.agents.agent_toolkits import create_python_agent
from langchain.tools.python.tool import PythonREPLTool
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain.document_loaders import WebBaseLoader
from langchain.agents import Tool, initialize_agent, AgentType
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import LanceDB
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferWindowMemory
from app.task import Task, TaskDescription, TaskList
from dotenv import load_dotenv
from fastapi import FastAPI, HTTPException, BackgroundTasks
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
import lancedb
## Set Env Variables
if None == os.environ.get('OPENAI_API_KEY'):
raise ValueError("Env OPENAI_API_KEY not set")
else:
OAI_TOKEN = os.environ.get('OPENAI_API_KEY')
if None == os.environ.get('OPENAI_CHAT_MODEL'):
OPENAI_CHAT_MODEL = "gpt-3.5-turbo-0613"
else:
OPENAI_CHAT_MODEL = os.environ.get('OPENAI_CHAT_MODEL')
if None == os.environ.get('OPENAI_CHAT_TEMPERATURE'):
OPENAI_CHAT_TEMPERATURE = 0.3
else:
OPENAI_CHAT_TEMPERATURE = os.environ.get('OPENAI_CHAT_TEMPERATURE')
if None == os.environ.get('OPENAI_MAX_CHAT_TOKENS'):
OPENAI_MAX_CHAT_TOKENS = 200
else:
OPENAI_MAX_CHAT_TOKENS = os.environ.get('OPENAI_MAX_CHAT_TOKENS')
if None == os.environ.get('OPENAI_RESEARCH_MODEL'):
OPENAI_RESEARCH_MODEL = "gpt-3.5-turbo-16k-0613"
else:
OPENAI_RESEARCH_MODEL = os.environ.get('OPENAI_RESEARCH_MODEL')
if None == os.environ.get('OPENAI_RESEARCH_TEMPERATURE'):
OPENAI_RESEARCH_TEMPERATURE = 0.1
else:
OPENAI_RESEARCH_TEMPERATURE = os.environ.get('OPENAI_RESEARCH_TEMPERATURE')
if None == os.environ.get('OPENAI_MAX_RESEARCH_TOKENS'):
OPENAI_MAX_RESEARCH_TOKENS = 500
else:
OPENAI_MAX_RESEARCH_TOKENS = os.environ.get('OPENAI_MAX_RESEARCH_TOKENS')
if None == os.environ.get('HELIOS_URL'):
HELIOS_URL = "helios.latrobe.group"
else:
HELIOS_URL = os.environ.get('HELIOS_URL')
## Set up OpenAI
VERBOSE = False
chat_model = ChatOpenAI(
temperature=OPENAI_CHAT_TEMPERATURE,
max_tokens=OPENAI_MAX_CHAT_TOKENS,
model=OPENAI_CHAT_MODEL,
)
research_model = ChatOpenAI(
temperature=OPENAI_RESEARCH_TEMPERATURE,
max_tokens=OPENAI_MAX_RESEARCH_TOKENS,
model=OPENAI_RESEARCH_MODEL,
)
embeddings = OpenAIEmbeddings()
## Set up FastAPI
helios_app = FastAPI()
origins = [
f"http://{HELIOS_URL}",
f"https://{HELIOS_URL}",
"http://localhost",
"http://localhost:8000",
]
helios_app.add_middleware(
CORSMiddleware,
allow_credentials=True,
allow_origins=origins,
allow_methods=["*"],
allow_headers=["*"],
)
## Set up Task Queue
TASKS = TaskList()
## Set up knowledge VectorStore and retriever chain
db_name = "./helios_kb.db"
table_name = "helios_kb"
db = lancedb.connect(db_name)
if table_name not in db.table_names():
table = db.create_table(
"helios_kb",
data=[
{
"vector": embeddings.embed_query("You are Helios, an AI chatbot that can perform background research tasks."),
"text": "You are Helios, an AI chatbot that can perform background research tasks with access to the internet.",
"id": "1",
}
],
mode="create",
)
else:
table = db.open_table(table_name)
vectorstore = LanceDB(connection=table, embedding=embeddings)
kb_retriever = vectorstore.as_retriever()
def check_search_result(query: str, result: str) -> bool:
'''Checks if the result of a search is a well informed answer to the query.'''
prompt = PromptTemplate(
input_variables=["search_query", "search_response"],
template="Answer only 'Yes' or 'No' only - did the following response actually answer the question or include the right information to help the user with the query - yes or no:\n#####\nQuery: {search_query}\n#####\nResponse:{search_response}",
)
chain = LLMChain(llm=chat_model, prompt=prompt)
check_response = chain.run(
{
"search_query": query,
"search_response": result,
}
)
if "YES" in check_response.upper():
pass
else:
add_new_task(description=f"Use all of your tools to research this query: {query}")
def search_kb(query: str) -> str:
compressor = LLMChainExtractor.from_llm(research_model)
compression_retriever = ContextualCompressionRetriever(base_compressor=compressor, base_retriever=kb_retriever)
compressed_docs = compression_retriever.get_relevant_documents(query)
return compressed_docs
## Define Helper Functions
def add_new_task(description: str) -> Task:
'''Adds a new task to the task queue.'''
task_id = len(TASKS)
task = Task(task_id=task_id, description=description)
print(f"Adding new task: {description}")
task.pending()
TASKS.append(task)
return task
def do_tasks():
'''Runs the task queue.'''
pending_tasks = [t for t in TASKS if t.get_status() == 'pending']
for TASK in pending_tasks:
run_task(task=TASK)
def run_task(task: Task):
'''Runs a task.'''
task.running()
response = research_agent.run("Use your tools to create a knowledge graph on this topic: {TASK}".format(TASK=task.description))
vectorstore.add_texts(texts=[response], metadatas=[{"id": task.task_id, "task": task.description}])
task.done(result=response)
return task
def load_web_page(url: str) -> str:
'''Loads a web page and returns the text.'''
loader = WebBaseLoader(url)
loader.requests_kwargs = {'verify':False}
data = loader.load()
return f"Text from {url}:\n{data}"
## Set up LangChain Agents
python_agent = create_python_agent(
llm=research_model,
tool=PythonREPLTool(),
agent_type=AgentType.OPENAI_FUNCTIONS,
agent_executor_kwargs={"handle_parsing_errors": True},
)
chat_tools = [
Tool(
name="knowledgebase-search",
func=search_kb,
description="Searches the knowledge base for information. Input must be a list of key words or search terms.",
),
Tool(
name="add-research-task",
func=add_new_task,
description="If the knowledgebase doesn't have an answer, use this tool to start a background research task. Input must be a description of new research or a task to be done.",
)
]
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
search = DuckDuckGoSearchRun()
research_tools = [
Tool(
name="knowledgebase-search",
func=search_kb,
description="Searches the knowledge base for information. Input must be a list of key words or search terms.",
),
Tool(
name="wikipedia-search",
func=wikipedia.run,
description="Searches Wikipedia information about people, places and historical facts. Input must be a list of key words or search terms.",
),
Tool(
name="web-search",
func=search.run,
description="Searches the web using DuckDuckGo for information from web pages. Input must be a list of key words or search terms.",
),
Tool(
name="run-python-code",
func=python_agent.run,
description="Sends a task to another agent that will write and run custom python code to achieve a task. Input must be a task or goal that a python programmer could achieve.",
),
Tool(
name="add-research-task",
func=add_new_task,
description="Only use this tool if the user asks you to add a new task. Input must be a description of new research or a task to be done.",
)
]
agent_kwargs = {
"extra_prompt_messages": [MessagesPlaceholder(variable_name="memory")],
}
memory = ConversationBufferWindowMemory(memory_key="memory", return_messages=True, k=4)
## Init Agents
chat_agent = initialize_agent(
chat_tools,
chat_model,
agent=AgentType.OPENAI_MULTI_FUNCTIONS,
agent_kwargs=agent_kwargs,
memory=memory,
handle_parsing_errors=True,
verbose=VERBOSE)
research_agent = initialize_agent(
research_tools,
research_model,
agent=AgentType.OPENAI_MULTI_FUNCTIONS,
handle_parsing_errors=True,
verbose=VERBOSE)
## Add FastAPI Routes:
@helios_app.get("/")
async def root(background_tasks: BackgroundTasks):
'''Returns the status of the bot.'''
background_tasks.add_task(do_tasks)
return {"status": "ok",
"version": "helios v{VERSION}".format(VERSION=os.environ.get('VERSION'))}
@helios_app.get("/tasks")
async def get_tasks(background_tasks: BackgroundTasks):
'''Returns a list of all tasks and their status.'''
background_tasks.add_task(do_tasks)
return TASKS.model_dump_json(indent = 2)
@helios_app.get("/tasks/{task_id}")
async def get_task(task_id: int, background_tasks: BackgroundTasks):
'''Returns the status of a specific task.'''
background_tasks.add_task(do_tasks)
return TASKS[task_id].model_dump_json(indent = 2)
@helios_app.post("/tasks/")
async def create_task(task: TaskDescription, background_tasks: BackgroundTasks):
'''Creates a new task.'''
new_task = add_new_task(task.description)
background_tasks.add_task(do_tasks)
if isinstance(new_task, Task):
background_tasks.add_task(do_tasks)
return new_task.model_dump_json(indent = 2)
else:
raise HTTPException(status_code=500, detail="Task creation failed")
class SearchQuery(BaseModel):
q: str
@helios_app.post("/search/")
async def search(q: SearchQuery, background_tasks: BackgroundTasks):
'''Searches the knowledgebase for an answer to a question.'''
response = search_kb(q.q)
background_tasks.add_task(check_search_result, q.q, response)
background_tasks.add_task(do_tasks)
return response
class ChatMessage(BaseModel):
message: str
@helios_app.post("/chat/")
async def chat(message: ChatMessage, background_tasks: BackgroundTasks):
'''Chats with the bot.'''
agent_prompt = f"Use your tools to give a detailed answer to this message - if you can't find the answer, say I don't know: {message.message}"
response = chat_agent.run(agent_prompt)
response = response.replace("\n", "<br />").replace("\r", "").replace("\"", "'")
background_tasks.add_task(check_search_result, message.message, response)
background_tasks.add_task(do_tasks)
return response | [
"lancedb.connect"
] | [((2468, 2580), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': 'OPENAI_CHAT_TEMPERATURE', 'max_tokens': 'OPENAI_MAX_CHAT_TOKENS', 'model': 'OPENAI_CHAT_MODEL'}), '(temperature=OPENAI_CHAT_TEMPERATURE, max_tokens=\n OPENAI_MAX_CHAT_TOKENS, model=OPENAI_CHAT_MODEL)\n', (2478, 2580), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2608, 2732), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': 'OPENAI_RESEARCH_TEMPERATURE', 'max_tokens': 'OPENAI_MAX_RESEARCH_TOKENS', 'model': 'OPENAI_RESEARCH_MODEL'}), '(temperature=OPENAI_RESEARCH_TEMPERATURE, max_tokens=\n OPENAI_MAX_RESEARCH_TOKENS, model=OPENAI_RESEARCH_MODEL)\n', (2618, 2732), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2756, 2774), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (2772, 2774), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((2807, 2816), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (2814, 2816), False, 'from fastapi import FastAPI, HTTPException, BackgroundTasks\n'), ((3125, 3135), 'app.task.TaskList', 'TaskList', ([], {}), '()\n', (3133, 3135), False, 'from app.task import Task, TaskDescription, TaskList\n'), ((3246, 3270), 'lancedb.connect', 'lancedb.connect', (['db_name'], {}), '(db_name)\n', (3261, 3270), False, 'import lancedb\n'), ((3784, 3831), 'langchain.vectorstores.LanceDB', 'LanceDB', ([], {'connection': 'table', 'embedding': 'embeddings'}), '(connection=table, embedding=embeddings)\n', (3791, 3831), False, 'from langchain.vectorstores import LanceDB\n'), ((6844, 6865), 'langchain.tools.DuckDuckGoSearchRun', 'DuckDuckGoSearchRun', ([], {}), '()\n', (6863, 6865), False, 'from langchain.tools import DuckDuckGoSearchRun\n'), ((8113, 8191), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'memory_key': '"""memory"""', 'return_messages': '(True)', 'k': '(4)'}), "(memory_key='memory', return_messages=True, k=4)\n", (8143, 8191), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((8221, 8397), 'langchain.agents.initialize_agent', 'initialize_agent', (['chat_tools', 'chat_model'], {'agent': 'AgentType.OPENAI_MULTI_FUNCTIONS', 'agent_kwargs': 'agent_kwargs', 'memory': 'memory', 'handle_parsing_errors': '(True)', 'verbose': 'VERBOSE'}), '(chat_tools, chat_model, agent=AgentType.\n OPENAI_MULTI_FUNCTIONS, agent_kwargs=agent_kwargs, memory=memory,\n handle_parsing_errors=True, verbose=VERBOSE)\n', (8237, 8397), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((8438, 8576), 'langchain.agents.initialize_agent', 'initialize_agent', (['research_tools', 'research_model'], {'agent': 'AgentType.OPENAI_MULTI_FUNCTIONS', 'handle_parsing_errors': '(True)', 'verbose': 'VERBOSE'}), '(research_tools, research_model, agent=AgentType.\n OPENAI_MULTI_FUNCTIONS, handle_parsing_errors=True, verbose=VERBOSE)\n', (8454, 8576), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((1115, 1147), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (1129, 1147), False, 'import os\n'), ((1222, 1254), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (1236, 1254), False, 'import os\n'), ((1267, 1302), 'os.environ.get', 'os.environ.get', (['"""OPENAI_CHAT_MODEL"""'], {}), "('OPENAI_CHAT_MODEL')\n", (1281, 1302), False, 'import os\n'), ((1379, 1414), 'os.environ.get', 'os.environ.get', (['"""OPENAI_CHAT_MODEL"""'], {}), "('OPENAI_CHAT_MODEL')\n", (1393, 1414), False, 'import os\n'), ((1427, 1468), 'os.environ.get', 'os.environ.get', (['"""OPENAI_CHAT_TEMPERATURE"""'], {}), "('OPENAI_CHAT_TEMPERATURE')\n", (1441, 1468), False, 'import os\n'), ((1540, 1581), 'os.environ.get', 'os.environ.get', (['"""OPENAI_CHAT_TEMPERATURE"""'], {}), "('OPENAI_CHAT_TEMPERATURE')\n", (1554, 1581), False, 'import os\n'), ((1594, 1634), 'os.environ.get', 'os.environ.get', (['"""OPENAI_MAX_CHAT_TOKENS"""'], {}), "('OPENAI_MAX_CHAT_TOKENS')\n", (1608, 1634), False, 'import os\n'), ((1704, 1744), 'os.environ.get', 'os.environ.get', (['"""OPENAI_MAX_CHAT_TOKENS"""'], {}), "('OPENAI_MAX_CHAT_TOKENS')\n", (1718, 1744), False, 'import os\n'), ((1757, 1796), 'os.environ.get', 'os.environ.get', (['"""OPENAI_RESEARCH_MODEL"""'], {}), "('OPENAI_RESEARCH_MODEL')\n", (1771, 1796), False, 'import os\n'), ((1885, 1924), 'os.environ.get', 'os.environ.get', (['"""OPENAI_RESEARCH_MODEL"""'], {}), "('OPENAI_RESEARCH_MODEL')\n", (1899, 1924), False, 'import os\n'), ((1937, 1982), 'os.environ.get', 'os.environ.get', (['"""OPENAI_RESEARCH_TEMPERATURE"""'], {}), "('OPENAI_RESEARCH_TEMPERATURE')\n", (1951, 1982), False, 'import os\n'), ((2062, 2107), 'os.environ.get', 'os.environ.get', (['"""OPENAI_RESEARCH_TEMPERATURE"""'], {}), "('OPENAI_RESEARCH_TEMPERATURE')\n", (2076, 2107), False, 'import os\n'), ((2120, 2164), 'os.environ.get', 'os.environ.get', (['"""OPENAI_MAX_RESEARCH_TOKENS"""'], {}), "('OPENAI_MAX_RESEARCH_TOKENS')\n", (2134, 2164), False, 'import os\n'), ((2242, 2286), 'os.environ.get', 'os.environ.get', (['"""OPENAI_MAX_RESEARCH_TOKENS"""'], {}), "('OPENAI_MAX_RESEARCH_TOKENS')\n", (2256, 2286), False, 'import os\n'), ((2299, 2327), 'os.environ.get', 'os.environ.get', (['"""HELIOS_URL"""'], {}), "('HELIOS_URL')\n", (2313, 2327), False, 'import os\n'), ((2392, 2420), 'os.environ.get', 'os.environ.get', (['"""HELIOS_URL"""'], {}), "('HELIOS_URL')\n", (2406, 2420), False, 'import os\n'), ((4029, 4354), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['search_query', 'search_response']", 'template': '"""Answer only \'Yes\' or \'No\' only - did the following response actually answer the question or include the right information to help the user with the query - yes or no:\n#####\nQuery: {search_query}\n#####\nResponse:{search_response}"""'}), '(input_variables=[\'search_query\', \'search_response\'],\n template=\n """Answer only \'Yes\' or \'No\' only - did the following response actually answer the question or include the right information to help the user with the query - yes or no:\n#####\nQuery: {search_query}\n#####\nResponse:{search_response}"""\n )\n', (4043, 4354), False, 'from langchain.prompts import PromptTemplate, MessagesPlaceholder\n'), ((4376, 4415), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'chat_model', 'prompt': 'prompt'}), '(llm=chat_model, prompt=prompt)\n', (4384, 4415), False, 'from langchain.chains import LLMChain\n'), ((4754, 4796), 'langchain.retrievers.document_compressors.LLMChainExtractor.from_llm', 'LLMChainExtractor.from_llm', (['research_model'], {}), '(research_model)\n', (4780, 4796), False, 'from langchain.retrievers.document_compressors import LLMChainExtractor\n'), ((4825, 4917), 'langchain.retrievers.ContextualCompressionRetriever', 'ContextualCompressionRetriever', ([], {'base_compressor': 'compressor', 'base_retriever': 'kb_retriever'}), '(base_compressor=compressor, base_retriever=\n kb_retriever)\n', (4855, 4917), False, 'from langchain.retrievers import ContextualCompressionRetriever\n'), ((5167, 5213), 'app.task.Task', 'Task', ([], {'task_id': 'task_id', 'description': 'description'}), '(task_id=task_id, description=description)\n', (5171, 5213), False, 'from app.task import Task, TaskDescription, TaskList\n'), ((5945, 5963), 'langchain.document_loaders.WebBaseLoader', 'WebBaseLoader', (['url'], {}), '(url)\n', (5958, 5963), False, 'from langchain.document_loaders import WebBaseLoader\n'), ((6312, 6482), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""knowledgebase-search"""', 'func': 'search_kb', 'description': '"""Searches the knowledge base for information. Input must be a list of key words or search terms."""'}), "(name='knowledgebase-search', func=search_kb, description=\n 'Searches the knowledge base for information. Input must be a list of key words or search terms.'\n )\n", (6316, 6482), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((6509, 6745), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""add-research-task"""', 'func': 'add_new_task', 'description': '"""If the knowledgebase doesn\'t have an answer, use this tool to start a background research task. Input must be a description of new research or a task to be done."""'}), '(name=\'add-research-task\', func=add_new_task, description=\n "If the knowledgebase doesn\'t have an answer, use this tool to start a background research task. Input must be a description of new research or a task to be done."\n )\n', (6513, 6745), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((6889, 7059), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""knowledgebase-search"""', 'func': 'search_kb', 'description': '"""Searches the knowledge base for information. Input must be a list of key words or search terms."""'}), "(name='knowledgebase-search', func=search_kb, description=\n 'Searches the knowledge base for information. Input must be a list of key words or search terms.'\n )\n", (6893, 7059), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((7086, 7285), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""wikipedia-search"""', 'func': 'wikipedia.run', 'description': '"""Searches Wikipedia information about people, places and historical facts. Input must be a list of key words or search terms."""'}), "(name='wikipedia-search', func=wikipedia.run, description=\n 'Searches Wikipedia information about people, places and historical facts. Input must be a list of key words or search terms.'\n )\n", (7090, 7285), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((7312, 7494), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""web-search"""', 'func': 'search.run', 'description': '"""Searches the web using DuckDuckGo for information from web pages. Input must be a list of key words or search terms."""'}), "(name='web-search', func=search.run, description=\n 'Searches the web using DuckDuckGo for information from web pages. Input must be a list of key words or search terms.'\n )\n", (7316, 7494), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((7521, 7758), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""run-python-code"""', 'func': 'python_agent.run', 'description': '"""Sends a task to another agent that will write and run custom python code to achieve a task. Input must be a task or goal that a python programmer could achieve."""'}), "(name='run-python-code', func=python_agent.run, description=\n 'Sends a task to another agent that will write and run custom python code to achieve a task. Input must be a task or goal that a python programmer could achieve.'\n )\n", (7525, 7758), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((7785, 7984), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""add-research-task"""', 'func': 'add_new_task', 'description': '"""Only use this tool if the user asks you to add a new task. Input must be a description of new research or a task to be done."""'}), "(name='add-research-task', func=add_new_task, description=\n 'Only use this tool if the user asks you to add a new task. Input must be a description of new research or a task to be done.'\n )\n", (7789, 7984), False, 'from langchain.agents import Tool, initialize_agent, AgentType\n'), ((6171, 6187), 'langchain.tools.python.tool.PythonREPLTool', 'PythonREPLTool', ([], {}), '()\n', (6185, 6187), False, 'from langchain.tools.python.tool import PythonREPLTool\n'), ((6812, 6833), 'langchain.utilities.WikipediaAPIWrapper', 'WikipediaAPIWrapper', ([], {}), '()\n', (6831, 6833), False, 'from langchain.utilities import WikipediaAPIWrapper\n'), ((8056, 8099), 'langchain.prompts.MessagesPlaceholder', 'MessagesPlaceholder', ([], {'variable_name': '"""memory"""'}), "(variable_name='memory')\n", (8075, 8099), False, 'from langchain.prompts import PromptTemplate, MessagesPlaceholder\n'), ((9741, 9802), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(500)', 'detail': '"""Task creation failed"""'}), "(status_code=500, detail='Task creation failed')\n", (9754, 9802), False, 'from fastapi import FastAPI, HTTPException, BackgroundTasks\n'), ((8859, 8884), 'os.environ.get', 'os.environ.get', (['"""VERSION"""'], {}), "('VERSION')\n", (8873, 8884), False, 'import os\n')] |
"""
Chatbot for talking to Github Codespaces using Langchain, Qwen and LanceDB
"""
import os
import shutil
import lancedb
from langchain.memory import ConversationSummaryMemory
from langchain_community.document_loaders import GitLoader
from langchain.vectorstores import LanceDB
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.chat_models import ChatOllama
from langchain.chains import ConversationalRetrievalChain
def lanceDBConnection(embed):
db = lancedb.connect("/tmp/lancedb")
table = db.create_table(
"github_repo",
data=[{"vector": embed.embed_query("Hello World"), "text": "Hello World"}],
mode="overwrite",
)
return table
def vectorStoreSetup(query_path):
temp_repo_dir = "./example_data/test_repo1/"
if os.path.exists(temp_repo_dir):
shutil.rmtree(temp_repo_dir)
docs = GitLoader(
clone_url=query_path,
repo_path=temp_repo_dir,
file_filter=lambda file_path: file_path.endswith(".py")
or file_path.endswith(".md")
or file_path.endswith(".js"),
)
docs = docs.load()
# chunking
text_splitter = CharacterTextSplitter(chunk_size=100, chunk_overlap=0)
all_splits = text_splitter.split_documents(docs)
# Huggingface embeddings
embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
# LanceDB as vector store
table = lanceDBConnection(embed)
vectorstore = LanceDB.from_documents(
documents=all_splits,
embedding=HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2"
),
connection=table,
)
return vectorstore
def retrieverSetup(text):
vectorstore = vectorStoreSetup(text)
# define ChatOllama: using Qwen model for LLM
llm = ChatOllama(model="qwen")
memory = ConversationSummaryMemory(
llm=llm, memory_key="chat_history", return_messages=True
)
retriever = vectorstore.as_retriever()
# define Retrieval Chain for retriver
qa = ConversationalRetrievalChain.from_llm(llm, retriever=retriever, memory=memory)
return qa
def chat(qa, question):
# chat query
r = qa.run({"question": question})
return r
| [
"lancedb.connect"
] | [((538, 569), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (553, 569), False, 'import lancedb\n'), ((848, 877), 'os.path.exists', 'os.path.exists', (['temp_repo_dir'], {}), '(temp_repo_dir)\n', (862, 877), False, 'import os\n'), ((1205, 1259), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(100)', 'chunk_overlap': '(0)'}), '(chunk_size=100, chunk_overlap=0)\n', (1226, 1259), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((1355, 1429), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""sentence-transformers/all-MiniLM-L6-v2"""'}), "(model_name='sentence-transformers/all-MiniLM-L6-v2')\n", (1376, 1429), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n'), ((1871, 1895), 'langchain.chat_models.ChatOllama', 'ChatOllama', ([], {'model': '"""qwen"""'}), "(model='qwen')\n", (1881, 1895), False, 'from langchain.chat_models import ChatOllama\n'), ((1909, 1996), 'langchain.memory.ConversationSummaryMemory', 'ConversationSummaryMemory', ([], {'llm': 'llm', 'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(llm=llm, memory_key='chat_history',\n return_messages=True)\n", (1934, 1996), False, 'from langchain.memory import ConversationSummaryMemory\n'), ((2102, 2180), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', (['llm'], {'retriever': 'retriever', 'memory': 'memory'}), '(llm, retriever=retriever, memory=memory)\n', (2139, 2180), False, 'from langchain.chains import ConversationalRetrievalChain\n'), ((887, 915), 'shutil.rmtree', 'shutil.rmtree', (['temp_repo_dir'], {}), '(temp_repo_dir)\n', (900, 915), False, 'import shutil\n'), ((1588, 1662), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""sentence-transformers/all-MiniLM-L6-v2"""'}), "(model_name='sentence-transformers/all-MiniLM-L6-v2')\n", (1609, 1662), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self, data: Union[str, Path] = "coco128.yaml", model: str = "yolov8n.pt", uri: str = "~/ultralytics/explorer"
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1680, 1873), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1686, 1873), False, 'from ultralytics.data.augment import Format\n'), ((2137, 2192), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2162, 2192), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2243, 2263), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2258, 2263), False, 'import lancedb\n'), ((2514, 2525), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2518, 2525), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3857, 3885), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3874, 3885), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8492, 8530), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8503, 8530), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((8545, 8562), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8555, 8562), False, 'import duckdb\n'), ((9524, 9544), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9539, 9544), False, 'from PIL import Image\n'), ((12169, 12189), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12184, 12189), False, 'from PIL import Image\n'), ((16441, 16460), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16449, 16460), True, 'import numpy as np\n'), ((16545, 16572), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16552, 16572), True, 'from matplotlib import pyplot as plt\n'), ((16622, 16644), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16632, 16644), True, 'from matplotlib import pyplot as plt\n'), ((16653, 16672), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16663, 16672), True, 'from matplotlib import pyplot as plt\n'), ((16681, 16710), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16690, 16710), True, 'from matplotlib import pyplot as plt\n'), ((16728, 16737), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16735, 16737), False, 'from io import BytesIO\n'), ((16746, 16779), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16757, 16779), True, 'from matplotlib import pyplot as plt\n'), ((3318, 3404), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3329, 3404), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((3506, 3616), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3517, 3616), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((9392, 9424), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9403, 9424), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((12036, 12068), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12047, 12068), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((13646, 13749), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13657, 13749), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((1190, 1201), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1197, 1201), True, 'import numpy as np\n'), ((1255, 1268), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1265, 1268), False, 'import cv2\n'), ((16899, 16917), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16909, 16917), False, 'from PIL import Image\n'), ((18135, 18234), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18147, 18234), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((18237, 18252), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18249, 18252), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2290, 2300), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2294, 2300), False, 'from pathlib import Path\n'), ((6717, 6736), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6728, 6736), False, 'import torch\n')] |
"""
Chatbot for talking to Podcast using Langchain, Ollama and LanceDB
"""
from langchain.document_loaders import DataFrameLoader
import pandas as pd
from langchain.memory import ConversationSummaryMemory
import lancedb
from langchain.vectorstores import LanceDB
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chat_models import ChatOllama
from langchain.chains import ConversationalRetrievalChain
def lanceDBConnection(dataset):
db = lancedb.connect("/tmp/lancedb")
table = db.create_table("tb", data=dataset, mode="overwrite")
return table
def vectorStoreSetup(text, OPENAI_KEY):
# OpenAI embeddings
embedding = OpenAIEmbeddings(openai_api_key=OPENAI_KEY)
emb = embedding.embed_query(text)
dataset = [{"vector": emb, "text": text}]
# LanceDB as vector store
table = lanceDBConnection(dataset)
df = pd.DataFrame(dataset)
loader = DataFrameLoader(df)
data = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(data)
vectorstore = LanceDB.from_documents(
documents=all_splits,
embedding=OpenAIEmbeddings(openai_api_key=OPENAI_KEY),
connection=table,
)
return vectorstore
def retrieverSetup(text, OPENAI_KEY):
vectorstore = vectorStoreSetup(text, OPENAI_KEY)
# define ChatOllama: by default takes llama2-4bit quantized model
llm = ChatOllama()
memory = ConversationSummaryMemory(
llm=llm, memory_key="chat_history", return_messages=True
)
retriever = vectorstore.as_retriever()
# define Retrieval Chain for retriver
qa = ConversationalRetrievalChain.from_llm(llm, retriever=retriever, memory=memory)
return qa
def chat(qa, question):
# chat query
r = qa.run({"question": question})
return r
| [
"lancedb.connect"
] | [((527, 558), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (542, 558), False, 'import lancedb\n'), ((724, 767), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'OPENAI_KEY'}), '(openai_api_key=OPENAI_KEY)\n', (740, 767), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((932, 953), 'pandas.DataFrame', 'pd.DataFrame', (['dataset'], {}), '(dataset)\n', (944, 953), True, 'import pandas as pd\n'), ((967, 986), 'langchain.document_loaders.DataFrameLoader', 'DataFrameLoader', (['df'], {}), '(df)\n', (982, 986), False, 'from langchain.document_loaders import DataFrameLoader\n'), ((1033, 1096), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(500)', 'chunk_overlap': '(0)'}), '(chunk_size=500, chunk_overlap=0)\n', (1063, 1096), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1514, 1526), 'langchain.chat_models.ChatOllama', 'ChatOllama', ([], {}), '()\n', (1524, 1526), False, 'from langchain.chat_models import ChatOllama\n'), ((1540, 1627), 'langchain.memory.ConversationSummaryMemory', 'ConversationSummaryMemory', ([], {'llm': 'llm', 'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(llm=llm, memory_key='chat_history',\n return_messages=True)\n", (1565, 1627), False, 'from langchain.memory import ConversationSummaryMemory\n'), ((1733, 1811), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', (['llm'], {'retriever': 'retriever', 'memory': 'memory'}), '(llm, retriever=retriever, memory=memory)\n', (1770, 1811), False, 'from langchain.chains import ConversationalRetrievalChain\n'), ((1241, 1284), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'OPENAI_KEY'}), '(openai_api_key=OPENAI_KEY)\n', (1257, 1284), False, 'from langchain.embeddings import OpenAIEmbeddings\n')] |
import flask
import lancedb
import openai
import langchain
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import LanceDB
from langchain.docstore.document import Document
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
import os
from flask import Flask, render_template, request, jsonify
from flask import Response
from flask_cors import CORS
app = Flask(__name__)
# cors = CORS(app, resources={r"/*": {"origins": "*"}})
# from dotenv import dotenv_values
# env_vars = dotenv_values('.env')
env_vars = {'OPENAI_API_KEY': 'sk-1234'}
uri = "~/.lancedb"
db = lancedb.connect(uri)
app = Flask(__name__)
OPENAI_API_KEY = env_vars['OPENAI_API_KEY']
# Route for "/" for a web-based interface to this micro-service:
@app.route('/')
def index():
return "Hello, World"
@app.after_request
def add_cors_headers(response):
response.headers.add('Access-Control-Allow-Origin', '*')
response.headers.add('Access-Control-Allow-Headers', 'Content-Type')
response.headers.add('Access-Control-Allow-Methods', 'POST, OPTIONS')
return response
@app.route('/test', methods=['POST'])
def test():
# Process the request
data = request.get_json()
print(data)
print("TESTING")
# Generate the response
response_data = {'message': 'Hello, World'}
response = jsonify(response_data)
return response
# Handle OPTIONS request for CORS preflight
@app.route('/test', methods=['OPTIONS'])
def handle_options():
response = jsonify({'message': 'Preflight request received'})
response.headers.add('Access-Control-Allow-Origin', '*')
response.headers.add('Access-Control-Allow-Headers', 'Content-Type')
response.headers.add('Access-Control-Allow-Methods', 'POST')
print('Testing')
return response
@app.route('/store', methods = ['POST'])
def store_embedding():
json_data = request.get_json()
text = json_data['raw_text']
metadata = json_data['metadata']
document = Document(page_content=text, metadata=metadata)
chunks = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0).split_documents([document])
embeddings = OpenAIEmbeddings()
table = db.create_table("text", data=[
{"vector": embeddings.embed_query("Hello World"), "text": "Hello World", "id": "1"}
], mode="overwrite")
docsearch = LanceDB.from_documents(chunks, embeddings, connection=table)
return "Loaded Document Into Table"
@app.route('/retrieve', methods = ['POST'])
def retrieve_embedding():
json_data = request.get_json()
query = json_data['query']
assert len(openai.Model.list()["data"]) > 0
def embed_func(query):
rs = openai.Embedding.create(input=query, engine="text-embedding-ada-002")
return [record["embedding"] for record in rs["data"]]
query_vector = embed_func([query])[0]
table = db.open_table("text")
docs = table.search(query_vector).limit(10).to_df()
print(docs)
return docs
if __name__ == '__main__':
app.run(debug=True)
| [
"lancedb.connect"
] | [((448, 463), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (453, 463), False, 'from flask import Flask, render_template, request, jsonify\n'), ((658, 678), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (673, 678), False, 'import lancedb\n'), ((685, 700), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (690, 700), False, 'from flask import Flask, render_template, request, jsonify\n'), ((1234, 1252), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (1250, 1252), False, 'from flask import Flask, render_template, request, jsonify\n'), ((1382, 1404), 'flask.jsonify', 'jsonify', (['response_data'], {}), '(response_data)\n', (1389, 1404), False, 'from flask import Flask, render_template, request, jsonify\n'), ((1549, 1599), 'flask.jsonify', 'jsonify', (["{'message': 'Preflight request received'}"], {}), "({'message': 'Preflight request received'})\n", (1556, 1599), False, 'from flask import Flask, render_template, request, jsonify\n'), ((1921, 1939), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (1937, 1939), False, 'from flask import Flask, render_template, request, jsonify\n'), ((2025, 2071), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'text', 'metadata': 'metadata'}), '(page_content=text, metadata=metadata)\n', (2033, 2071), False, 'from langchain.docstore.document import Document\n'), ((2186, 2204), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (2202, 2204), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((2383, 2443), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['chunks', 'embeddings'], {'connection': 'table'}), '(chunks, embeddings, connection=table)\n', (2405, 2443), False, 'from langchain.vectorstores import LanceDB\n'), ((2576, 2594), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (2592, 2594), False, 'from flask import Flask, render_template, request, jsonify\n'), ((2716, 2785), 'openai.Embedding.create', 'openai.Embedding.create', ([], {'input': 'query', 'engine': '"""text-embedding-ada-002"""'}), "(input=query, engine='text-embedding-ada-002')\n", (2739, 2785), False, 'import openai\n'), ((2085, 2140), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(0)'}), '(chunk_size=1000, chunk_overlap=0)\n', (2106, 2140), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((2640, 2659), 'openai.Model.list', 'openai.Model.list', ([], {}), '()\n', (2657, 2659), False, 'import openai\n')] |
import os
import sys
import shutil
import platform
import argparse
import lancedb
import time
import uuid
import toml
import pyarrow as pa
import pyarrow.parquet as pq
from dotenv import load_dotenv, find_dotenv
from pymilvus import (
utility,
connections,
FieldSchema,
CollectionSchema,
DataType,
Collection,
)
from qdrant_client import QdrantClient, models
from qdrant_client.http.models import Distance, VectorParams, PointStruct
# Constants
DEFAULT_CONFIG_FILE = "configs/default.toml"
MILVUS_MAX_BATCH_SIZE = 10000
QDRANT_MAX_BATCH_SIZE = 1000
# Import ChromaDB properly
if platform.system() == "Linux":
__import__('pysqlite3')
import sys
sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
import chromadb
# Load the environment variables
load_dotenv(find_dotenv())
def read_toml_file(file_path):
with open(file_path, "r") as f:
return toml.load(f)
def read_parquet_file(file_path):
table = pq.read_table(file_path)
df = table.to_pandas()
lst = df.values.tolist()
return lst
def create_batches(l, n):
# looping till length l
for i in range(0, len(l), n):
yield l[i:i + n]
def init_db_collection(config):
if config["database"] == "chroma":
if os.path.exists("./chroma_db"):
shutil.rmtree("./chroma_db")
db = chromadb.PersistentClient(path="./chroma_db")
collection = db.get_or_create_collection(config["table"])
elif config["database"] == "lance":
if os.path.exists("./lance_db"):
shutil.rmtree("./lance_db")
db = lancedb.connect("./lance_db")
schema = pa.schema(
[
pa.field("embedding", pa.list_(pa.float32(), list_size=config["dimension"])),
pa.field("token", pa.string()),
pa.field("id", pa.int64()),
])
collection = db.create_table(config["table"], schema=schema)
elif config["database"] == "milvus":
connections.connect("default", host="localhost", port="19530")
if utility.has_collection(config["table"]):
utility.drop_collection(config["table"])
fields = [
FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
FieldSchema(name="token", dtype=DataType.VARCHAR, max_length=16384),
FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=config["dimension"])
]
schema = CollectionSchema(fields, config["table"])
collection = Collection(config["table"], schema)
elif config["database"] == "qdrant":
collection = QdrantClient("localhost", port=6333)
collection.delete_collection(collection_name=config["table"])
collection.create_collection(
collection_name=config["table"],
vectors_config=VectorParams(size=config["dimension"], distance=Distance.DOT),
optimizers_config=models.OptimizersConfigDiff(
indexing_threshold=0,
),
)
return collection
def init_client(config):
if config["database"] == "qdrant":
return QdrantClient("localhost", port=6333)
def run_query(config, client, vector):
if config["database"] == "qdrant":
results = client.search(
collection_name=config["table"],
query_vector=vector,
with_vectors=True,
with_payload=True,
limit=config["top_k"],
)
for idx, point in enumerate(results):
print(f"[INFO] Score #{idx}: {point.score}")
def insert_into_collection_bulk(collection, batch, config):
if config["database"] == "milvus":
mini_batches = list(create_batches(batch, MILVUS_MAX_BATCH_SIZE))
for b in mini_batches:
s = time.time()
collection.insert([
# Add an Id to the row (probably uuid.uuid4() would be a good idea)
[str(uuid.uuid4()) for _ in b],
[row[config["payload_idx"]] for row in b],
[list(row[config["embedding_idx"]]) for row in b],
])
print(f"[INFO] Inserted batch of size {len(b)} in {time.time() - s} seconds")
elif config["database"] == "chroma":
collection.add(
ids=[str(idx) for idx, _ in enumerate(batch)],
documents=[row[config["payload_idx"]] for row in batch],
embeddings=[list(row[config["embedding_idx"]]) for row in batch],
)
elif config["database"] == "lance":
collection.add([
{
"id": idx,
"token": row[config["payload_idx"]],
"embedding": list(row[config["embedding_idx"]]),
} for idx, row in enumerate(batch)])
elif config["database"] == "qdrant":
mini_batches = list(create_batches(batch, QDRANT_MAX_BATCH_SIZE))
for b in mini_batches:
s = time.time()
collection.upsert(
collection_name=config["table"],
wait=True,
points=[
PointStruct(
id=str(uuid.uuid4()),
payload={"token": row[config["payload_idx"]]},
vector=list(row[config["embedding_idx"]]),
) for row in b
],
)
print(f"[INFO] Inserted batch of size {len(b)} in {time.time() - s} seconds")
def get_collection_info(collection, config):
if config["database"] == "milvus":
collection.flush()
print(collection.name)
print(collection.schema)
print(collection.num_entities)
elif config["database"] == "chroma":
print(collection.count())
elif config["database"] == "lance":
print(collection.schema)
print(collection.count_rows())
elif config["database"] == "qdrant":
print("Collection info")
print(collection.get_collection(collection_name=config["table"]))
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--bench", type=str, default="qdrant-1M-1536", help="The benchmark setup to use")
parser.add_argument("--debug", action="store_true", help="Whether to run the script in debug mode")
parser.add_argument("--query", action="store_true", help="Whether to run a query on the collection")
parser.add_argument("--ingest", action="store_true", help="Whether to ingest the embeddings into the collection")
args = parser.parse_args()
# Read the default config file
config = read_toml_file(DEFAULT_CONFIG_FILE)
config = {**config[args.bench]}
print("[INFO] Running with config: ")
print(config)
# Ingest the dataset
if args.ingest:
total_rows_written = 0
collection = init_db_collection(config)
# Read the parquet files
if args.debug:
file_list = os.listdir(config["dataset"])[:2]
else:
file_list = os.listdir(config["dataset"])[config["train_start_idx"]:config["train_stop_idx"]]
print(f"[INFO] Inserting {len(file_list)} files into collection {config['table']}")
# Insert the embeddings into the collection
for file in file_list:
batch = read_parquet_file(os.path.join(config["dataset"], file))
insert_into_collection_bulk(collection, batch, config)
total_rows_written += len(batch)
print(f"[INFO] Total rows written: {total_rows_written}")
# Print out collection stats after insertion
get_collection_info(collection, config)
# Query the dataset
if args.query:
queries_ran = 0
client = init_client(config)
file_list = os.listdir(config["dataset"])[config["query_start_idx"]:config["query_stop_idx"]]
print(f"[INFO] Running queries from {len(file_list)} files")
for file in file_list:
for row in read_parquet_file(os.path.join(config["dataset"], file)):
vector = row[config["embedding_idx"]]
print(f"[INFO] Running query #{queries_ran} for vector: [{vector[0]}, {vector[1]}, {vector[2]}, ...]")
run_query(config, client, vector)
queries_ran += 1
if queries_ran >= config["queries_to_run"]:
break
print("[INFO] Done!")
| [
"lancedb.connect"
] | [((605, 622), 'platform.system', 'platform.system', ([], {}), '()\n', (620, 622), False, 'import platform\n'), ((707, 735), 'sys.modules.pop', 'sys.modules.pop', (['"""pysqlite3"""'], {}), "('pysqlite3')\n", (722, 735), False, 'import sys\n'), ((798, 811), 'dotenv.find_dotenv', 'find_dotenv', ([], {}), '()\n', (809, 811), False, 'from dotenv import load_dotenv, find_dotenv\n'), ((958, 982), 'pyarrow.parquet.read_table', 'pq.read_table', (['file_path'], {}), '(file_path)\n', (971, 982), True, 'import pyarrow.parquet as pq\n'), ((6025, 6050), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (6048, 6050), False, 'import argparse\n'), ((897, 909), 'toml.load', 'toml.load', (['f'], {}), '(f)\n', (906, 909), False, 'import toml\n'), ((1257, 1286), 'os.path.exists', 'os.path.exists', (['"""./chroma_db"""'], {}), "('./chroma_db')\n", (1271, 1286), False, 'import os\n'), ((1342, 1387), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""./chroma_db"""'}), "(path='./chroma_db')\n", (1367, 1387), False, 'import chromadb\n'), ((3125, 3161), 'qdrant_client.QdrantClient', 'QdrantClient', (['"""localhost"""'], {'port': '(6333)'}), "('localhost', port=6333)\n", (3137, 3161), False, 'from qdrant_client import QdrantClient, models\n'), ((1300, 1328), 'shutil.rmtree', 'shutil.rmtree', (['"""./chroma_db"""'], {}), "('./chroma_db')\n", (1313, 1328), False, 'import shutil\n'), ((1505, 1533), 'os.path.exists', 'os.path.exists', (['"""./lance_db"""'], {}), "('./lance_db')\n", (1519, 1533), False, 'import os\n'), ((1588, 1617), 'lancedb.connect', 'lancedb.connect', (['"""./lance_db"""'], {}), "('./lance_db')\n", (1603, 1617), False, 'import lancedb\n'), ((3785, 3796), 'time.time', 'time.time', ([], {}), '()\n', (3794, 3796), False, 'import time\n'), ((7733, 7762), 'os.listdir', 'os.listdir', (["config['dataset']"], {}), "(config['dataset'])\n", (7743, 7762), False, 'import os\n'), ((1547, 1574), 'shutil.rmtree', 'shutil.rmtree', (['"""./lance_db"""'], {}), "('./lance_db')\n", (1560, 1574), False, 'import shutil\n'), ((1979, 2041), 'pymilvus.connections.connect', 'connections.connect', (['"""default"""'], {'host': '"""localhost"""', 'port': '"""19530"""'}), "('default', host='localhost', port='19530')\n", (1998, 2041), False, 'from pymilvus import utility, connections, FieldSchema, CollectionSchema, DataType, Collection\n'), ((2053, 2092), 'pymilvus.utility.has_collection', 'utility.has_collection', (["config['table']"], {}), "(config['table'])\n", (2075, 2092), False, 'from pymilvus import utility, connections, FieldSchema, CollectionSchema, DataType, Collection\n'), ((2459, 2500), 'pymilvus.CollectionSchema', 'CollectionSchema', (['fields', "config['table']"], {}), "(fields, config['table'])\n", (2475, 2500), False, 'from pymilvus import utility, connections, FieldSchema, CollectionSchema, DataType, Collection\n'), ((2522, 2557), 'pymilvus.Collection', 'Collection', (["config['table']", 'schema'], {}), "(config['table'], schema)\n", (2532, 2557), False, 'from pymilvus import utility, connections, FieldSchema, CollectionSchema, DataType, Collection\n'), ((6903, 6932), 'os.listdir', 'os.listdir', (["config['dataset']"], {}), "(config['dataset'])\n", (6913, 6932), False, 'import os\n'), ((6975, 7004), 'os.listdir', 'os.listdir', (["config['dataset']"], {}), "(config['dataset'])\n", (6985, 7004), False, 'import os\n'), ((7272, 7309), 'os.path.join', 'os.path.join', (["config['dataset']", 'file'], {}), "(config['dataset'], file)\n", (7284, 7309), False, 'import os\n'), ((7957, 7994), 'os.path.join', 'os.path.join', (["config['dataset']", 'file'], {}), "(config['dataset'], file)\n", (7969, 7994), False, 'import os\n'), ((2106, 2146), 'pymilvus.utility.drop_collection', 'utility.drop_collection', (["config['table']"], {}), "(config['table'])\n", (2129, 2146), False, 'from pymilvus import utility, connections, FieldSchema, CollectionSchema, DataType, Collection\n'), ((2178, 2253), 'pymilvus.FieldSchema', 'FieldSchema', ([], {'name': '"""id"""', 'dtype': 'DataType.INT64', 'is_primary': '(True)', 'auto_id': '(True)'}), "(name='id', dtype=DataType.INT64, is_primary=True, auto_id=True)\n", (2189, 2253), False, 'from pymilvus import utility, connections, FieldSchema, CollectionSchema, DataType, Collection\n'), ((2267, 2334), 'pymilvus.FieldSchema', 'FieldSchema', ([], {'name': '"""token"""', 'dtype': 'DataType.VARCHAR', 'max_length': '(16384)'}), "(name='token', dtype=DataType.VARCHAR, max_length=16384)\n", (2278, 2334), False, 'from pymilvus import utility, connections, FieldSchema, CollectionSchema, DataType, Collection\n'), ((2348, 2436), 'pymilvus.FieldSchema', 'FieldSchema', ([], {'name': '"""embedding"""', 'dtype': 'DataType.FLOAT_VECTOR', 'dim': "config['dimension']"}), "(name='embedding', dtype=DataType.FLOAT_VECTOR, dim=config[\n 'dimension'])\n", (2359, 2436), False, 'from pymilvus import utility, connections, FieldSchema, CollectionSchema, DataType, Collection\n'), ((2620, 2656), 'qdrant_client.QdrantClient', 'QdrantClient', (['"""localhost"""'], {'port': '(6333)'}), "('localhost', port=6333)\n", (2632, 2656), False, 'from qdrant_client import QdrantClient, models\n'), ((1788, 1799), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (1797, 1799), True, 'import pyarrow as pa\n'), ((1833, 1843), 'pyarrow.int64', 'pa.int64', ([], {}), '()\n', (1841, 1843), True, 'import pyarrow as pa\n'), ((4911, 4922), 'time.time', 'time.time', ([], {}), '()\n', (4920, 4922), False, 'import time\n'), ((1707, 1719), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (1717, 1719), True, 'import pyarrow as pa\n'), ((2837, 2898), 'qdrant_client.http.models.VectorParams', 'VectorParams', ([], {'size': "config['dimension']", 'distance': 'Distance.DOT'}), "(size=config['dimension'], distance=Distance.DOT)\n", (2849, 2898), False, 'from qdrant_client.http.models import Distance, VectorParams, PointStruct\n'), ((2930, 2979), 'qdrant_client.models.OptimizersConfigDiff', 'models.OptimizersConfigDiff', ([], {'indexing_threshold': '(0)'}), '(indexing_threshold=0)\n', (2957, 2979), False, 'from qdrant_client import QdrantClient, models\n'), ((3934, 3946), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (3944, 3946), False, 'import uuid\n'), ((4165, 4176), 'time.time', 'time.time', ([], {}), '()\n', (4174, 4176), False, 'import time\n'), ((5404, 5415), 'time.time', 'time.time', ([], {}), '()\n', (5413, 5415), False, 'import time\n'), ((5119, 5131), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (5129, 5131), False, 'import uuid\n')] |
import pandas as pd
from omnivector.abstraction import AbstractDB
class LanceDB(AbstractDB):
"""
LanceDB is a vector database that uses Lance to store and search vectors.
"""
def __init__(self):
super().__init__()
def create_index(self):
# not sure how to do this in Lance
pass
def delete(self, ids):
import lancedb
db = lancedb.connect(self.config["lancedb"]["DB_PATH"])
tbl = db.open_table("my_table")
ids = ", ".join(str(v) for v in ids)
tbl.delete(f"id IN ({ids})")
def add(self, ids, vectors, metadata=None):
import lancedb
data = pd.DataFrame({"id": ids})
db = lancedb.connect(self.config["lancedb"]["DB_PATH"])
if metadata is not None:
meta_df = pd.DataFrame.from_records(metadata)
data = pd.concat([data, meta_df], axis=1)
data["vector"] = vectors.tolist()
try:
tbl = db.open_table("my_table")
tbl.add(data)
except:
db.create_table("my_table", data)
def vector_search(self, vector, k=3):
import lancedb
db = lancedb.connect(self.config["lancedb"]["DB_PATH"])
tbl = db.open_table("my_table")
return tbl.search(vector).limit(k).to_df()
| [
"lancedb.connect"
] | [((388, 438), 'lancedb.connect', 'lancedb.connect', (["self.config['lancedb']['DB_PATH']"], {}), "(self.config['lancedb']['DB_PATH'])\n", (403, 438), False, 'import lancedb\n'), ((650, 675), 'pandas.DataFrame', 'pd.DataFrame', (["{'id': ids}"], {}), "({'id': ids})\n", (662, 675), True, 'import pandas as pd\n'), ((690, 740), 'lancedb.connect', 'lancedb.connect', (["self.config['lancedb']['DB_PATH']"], {}), "(self.config['lancedb']['DB_PATH'])\n", (705, 740), False, 'import lancedb\n'), ((1157, 1207), 'lancedb.connect', 'lancedb.connect', (["self.config['lancedb']['DB_PATH']"], {}), "(self.config['lancedb']['DB_PATH'])\n", (1172, 1207), False, 'import lancedb\n'), ((797, 832), 'pandas.DataFrame.from_records', 'pd.DataFrame.from_records', (['metadata'], {}), '(metadata)\n', (822, 832), True, 'import pandas as pd\n'), ((852, 886), 'pandas.concat', 'pd.concat', (['[data, meta_df]'], {'axis': '(1)'}), '([data, meta_df], axis=1)\n', (861, 886), True, 'import pandas as pd\n')] |
from typing import Union, List, Optional
import pandas as pd
from fastapi import FastAPI, BackgroundTasks, Query, WebSocket, WebSocketDisconnect
from fastapi.responses import FileResponse
import time
import os, json, urllib
import lancedb
from pydantic import BaseModel
from . import backend
from .utils import get_full_book_name, get_book_abbreviation, embed_batch
from .types import Message, RequestModel, TranslationTriplet
import requests
import logging
logger = logging.getLogger('uvicorn')
app = FastAPI()
bsb_bible_df, macula_df = backend.get_dataframes() # Store these in global state
@app.get("/api/python")
def read_root():
return {"Hello": "World"}
# get bsb verse by ref
@app.get("/api/bsb_verses/{full_verse_ref}")
def read_item(full_verse_ref: str):
"""
Get verse from bsb_bible_df (Berean Standard Bible)
e.g., http://localhost:3000/api/bsb_verses/GEN%202:19
"""
logger.info('debug: ', bsb_bible_df.head())
verse = bsb_bible_df[bsb_bible_df['vref'] == full_verse_ref]
entry_number_of_verse = verse.index[0]
verse_output = {
'verse_number': int(entry_number_of_verse),
'vref': verse['vref'][entry_number_of_verse],
'content': verse['content'][entry_number_of_verse]
}
return verse_output
# get macula verse by ref
@app.get("/api/macula_verses/{full_verse_ref}")
def read_macula_verse_item(full_verse_ref: str):
"""
Get verse from macula_greek_df and macula_hebrew_df
e.g., http://localhost:3000/api/macula_verses/GEN%202:19
or NT: http://localhost:3000/api/macula_verses/ROM%202:19
"""
logger.info('full_verse_ref', full_verse_ref)
verse = macula_df[macula_df['vref'] == full_verse_ref]
entry_number_of_verse = verse.index[0]
verse_output = {
'verse_number': int(entry_number_of_verse),
'vref': verse['vref'][entry_number_of_verse],
'content': verse['content'][entry_number_of_verse]
}
return verse_output
# get target language data by language code
# @app.get("/api/target_vref_data/{language_code}")
# def read_target_language_item(language_code: str, drop_empty_verses: bool = False):
# """
# Get target language data by language code
# e.g., http://localhost:3000/api/target_vref_data/aai
# """
# target_vref_data = get_target_vref_df(language_code, drop_empty_verses=drop_empty_verses)
# return target_vref_data
@app.get("/api/download_triplets")
async def download_triplets(target_language_code: str, file_suffix: Optional[str] = None, force: bool=False):
print(f'target_language_code: {target_language_code}')
filename = f"{target_language_code}_triplets.json"
verse_triplets = {}
book_list = backend.get_vref_list()
for book in book_list:
vref_list = backend.get_vref_list(book)
# print(f'vref_list: {vref_list[:10]}')
for vref in vref_list:
verse_triplet = backend.get_verse_triplet(vref, target_language_code, bsb_bible_df, macula_df)
# print('verse_triplet', verse_triplet)
if verse_triplet is not None:
verse_triplets[vref] = verse_triplet
print(len(verse_triplets), 'verse triplets')
json_str = json.dumps(verse_triplets)
# Write the json_str to a file
with open(filename, 'w') as f:
f.write(json_str)
# return FileResponse(
# filename,
# media_type="application/json",
# headers={
# "Content-Disposition": f"attachment; filename={filename}"
# }
# )
return {"status": "Download started. Check back later for results."}
# get a single verse with source text and gloss, bsb english, and target language
@app.get("/api/verse/{full_verse_ref}&{language_code}")
def get_verse(full_verse_ref: str, language_code: str):
return backend.get_verse_triplet(full_verse_ref, language_code, bsb_bible_df, macula_df)
@app.get("/api/bible")
async def get_bible(language_code: str, file_suffix: Optional[str], force: Optional[bool], background_tasks: BackgroundTasks):
"""
Get the entire Bible from bsb_bible_df,
AND macula_df (greek and hebrew)
AND target_vref_data (target language)
e.g., http://localhost:3000/api/bible/aai
"""
filename = f'data/bible/{language_code}{file_suffix}.json'
# If the file exists and we're not forcing a reprocess, return it
if os.path.exists(filename) and not force:
return FileResponse(
filename,
media_type="application/json",
headers={
"Content-Disposition": f"attachment; filename={language_code}.json"
}
)
# Otherwise, start the long-running process in the background
background_tasks.add_task(process_bible, language_code, file_suffix)
return {"status": "Processing started. Check back later for results."}
async def process_bible(language_code: str, file_suffix: Optional[str] = None):
target_vref_df = backend.get_target_vref_df(language_code, file_suffix=file_suffix)
output = []
for vref in bsb_bible_df['vref']:
bsb_row = bsb_bible_df[bsb_bible_df['vref'] == vref]
macula_row = macula_df[macula_df['vref'] == vref]
target_row = target_vref_df[target_vref_df['vref'] == vref]
output.append({
'vref': vref,
'bsb': {
'vref': bsb_row['vref'].values[0] if not bsb_row.empty else '',
'content': bsb_row['content'].values[0] if not bsb_row.empty else ''
},
'macula': {
'vref': macula_row['vref'].values[0] if not macula_row.empty else '',
'content': macula_row['content'].values[0] if not macula_row.empty else ''
},
'target': {
'vref': target_row['vref'].values[0] if not target_row.empty else '',
'content': target_row['content'].values[0] if not target_row.empty else ''
}
})
# Save output to disk as `data/bible/{language_code}.json`
if not os.path.exists('data/bible'):
os.mkdir('data/bible')
with open(f'data/bible/{language_code}{file_suffix}.json', 'w') as f:
json.dump(output, f, ensure_ascii=False, indent=4)
# Return the file as a download
return FileResponse(
f'data/bible/{language_code}{file_suffix}.json',
media_type="application/json",
headers={
"Content-Disposition": f"attachment; filename={language_code}.json"
}
)
# endpoint to get table info
@app.get("/api/db_info")
def get_db_info():
output = []
db = lancedb.connect("./lancedb")
table = db.open_table('verses').to_pandas()
# Get unique languages in the table
languages = table['language'].unique()
output.append({
'name': 'verses',
'columns': list(table.columns),
'num_rows': len(table),
'languages': languages.tolist()
})
return output
@app.get("/api/populate_db")
def populate_db(target_language_code: str, file_suffix: str, background_tasks: BackgroundTasks):
"""
Populate database based on language code (3-char ISO 639-3 code).
Pulls data from bsb_bible_df, macula_df, and a target language scraped from the ebible corpus.
"""
# Check if db exists
if os.path.exists('./lancedb'):
db = lancedb.connect("./lancedb")
try:
table = db.open_table('verses').to_pandas()
if target_language_code in table['language'].unique():
return {"status": "Language already exists in the database. Please delete the language data and try again."}
except:
if target_language_code.startswith('init'): # To initialize databases
logger.info('Initializing Greek/Hebrew and English vectorstores...')
background_tasks.add_task(backend.create_lancedb_table_from_df, bsb_bible_df, 'verses') # load_database loads up the macula and bsb tables by default if they don't exist... Probably should make this less magical in the future
return {"status": f"Database initialization started for {target_language_code + file_suffix}... takes about 45 seconds for 10 lines of text and ~300 seconds for the whole Bible, so be patient!"}
logger.info('Populating database...')
background_tasks.add_task(backend.load_database, target_language_code, file_suffix)
return {"status": "Database population started... takes about 45 seconds for 10 lines of text and ~300 seconds for the whole Bible, so be patient!"}
@app.get("/api/query/{language_code}/{query}&limit={limit}")
def call_query_endpoint(language_code: str, query: str, limit: str = '10'):
return backend.query_lancedb_table(language_code, query, limit=limit)
# User should be able to submit vref + source language + target language to a /api/translation-prompt-builder/ endpoint
@app.get("/api/translation-prompt-builder")
def get_translation_prompt(vref: str, target_language_code: str, source_language_code: str='', bsb_bible_df=None, macula_df=None, number_of_examples: int = 3):
"""Get a forward-translation few-shot prompt for a given vref, source, and target language code."""
# Decode URI vref
vref = urllib.parse.unquote(vref)
print(f'vref: {vref}')
return backend.build_translation_prompt(vref, target_language_code, source_language_code=source_language_code, bsb_bible_df=bsb_bible_df, macula_df=macula_df, number_of_examples=number_of_examples)
@app.get("/api/vrefs/?book={book}")
def get_vrefs(book: str):
"""Get a list of vrefs from the ebible corpus."""
return backend.get_vref_list(book)
@app.get("/api/vrefs")
def get_vrefs():
"""Get a list of vrefs from the ebible corpus."""
return backend.get_vref_list()
@app.get("/api/unique_tokens")
def get_unique_tokens(language_code: str):
print(f'language_code: {language_code}')
"""Get a list of unique tokens from the ebible corpus texts by language code."""
return backend.get_unique_tokens_for_language(language_code)
'''
example post body:
{
"language_code": "aai",
"size": 3,
"n": 5,
"string_filter": [
"Ayu",
"Paul",
"Jesu",
"Keriso",
"ana",
"akir",
"wairafin",
"tur",
"abarin",
"isan",
"rubinu",
"naatu",
"Tur",
"Gewasin",
"binan",
"isan",
"God",
"eafu",
"atit"
]
}
'''
class NgramRequest(BaseModel):
language_code: str
size: int = 2
n: int = 100
string_filter: List[str] = []
@app.post("/api/ngrams")
def get_ngrams(request: NgramRequest):
return backend.get_ngrams(request.language_code, size=request.size, n=request.n, string_filter=request.string_filter)
class EvaluateTranslationRequest(BaseModel):
verse_triplets: dict[str, TranslationTriplet]
hypothesis_vref: str
@app.post("/api/evaluate")
def evaluate_translation_prompt(request: EvaluateTranslationRequest):
verse_triplets = request.verse_triplets
hypothesis_vref = request.hypothesis_vref
valid_vrefs = backend.get_vref_list(hypothesis_vref.split(' ')[0])
print(f'valid_vrefs: {valid_vrefs[:10]}')
if hypothesis_vref not in valid_vrefs:
return {"status": f"You submitted vref {hypothesis_vref}, but this vref is not in the ebible corpus. See https://raw.githubusercontent.com/BibleNLP/ebible/main/metadata/vref.txt for valid vrefs."}
prediction = backend.execute_discriminator_evaluation(verse_triplets, hypothesis_vref=hypothesis_vref)
return {"input_received": verse_triplets, "hypothesis_vref": hypothesis_vref, "prediction": prediction}
@app.get("/api/evaluate_test")
def evaluate_translation_prompt_test():
verse_triplets = {"ACT 13:47":{"Greek/Hebrew Source":"οὕτως γὰρ ἐντέταλται ἡμῖν ὁ Κύριος Τέθεικά σε εἰς φῶς ἐθνῶν τοῦ εἶναί σε εἰς σωτηρίαν ἕως ἐσχάτου τῆς γῆς.","English Reference":"For this is what the Lord has commanded us: ‘I have made you a light for the Gentiles, to bring salvation to the ends of the earth.’”","Target":"Anayabin Regah ana obaiyunen tur biti iti na’atube eo, ‘Ayu kwa ayasairi Ufun Sabuw hai marakaw isan, saise kwa i boro yawas kwanab kwanatit kwanan tafaram yomanin kwanatit.’"},"ACT 3:20":{"Greek/Hebrew Source":"ὅπως ἂν ἔλθωσιν καιροὶ ἀναψύξεως ἀπὸ προσώπου τοῦ Κυρίου καὶ ἀποστείλῃ τὸν προκεχειρισμένον ὑμῖν Χριστὸν Ἰησοῦν,","English Reference":"that times of refreshing may come from the presence of the Lord, and that He may send Jesus, the Christ, who has been appointed for you.","Target":"Nati namamatar ana veya, imaibo ayub ana fair bain baiboubun isan boro Regah wanawananamaim nan biya natit. Jesu, i ana Roubinineyan orot marasika kwa isa rurubin boro niyafar."},"LAM 2:13":{"Greek/Hebrew Source":"מָ֣ה אֲדַמֶּה־ לָּ֗ךְ הַבַּת֙ יְר֣וּשָׁלִַ֔ם מָ֤ה אַשְׁוֶה־ לָּךְ֙ וַאֲנַֽחֲמֵ֔ךְ בְּתוּלַ֖ת בַּת־ צִיּ֑וֹן כִּֽי־ גָד֥וֹל כַּיָּ֛ם שִׁבְרֵ֖ךְ מִ֥י יִרְפָּא־ לָֽךְ׃ס","English Reference":"What can I say for you? To what can I compare you, O Daughter of Jerusalem? To what can I liken you, that I may console you, O Virgin Daughter of Zion? For your wound is as deep as the sea. Who can ever heal you?","Target":""},"ROM 1:8":{"Greek/Hebrew Source":"Πρῶτον μὲν εὐχαριστῶ τῷ Θεῷ μου διὰ Ἰησοῦ Χριστοῦ περὶ πάντων ὑμῶν, ὅτι ἡ πίστις ὑμῶν καταγγέλλεται ἐν ὅλῳ τῷ κόσμῳ.","English Reference":"First, I thank my God through Jesus Christ for all of you, because your faith is being proclaimed all over the world.","Target":"This is the hypothesized verse translation."}}
verse_triplets: dict[str, TranslationTriplet] = { k: TranslationTriplet(**v) for k, v in verse_triplets.items() }
# return {"status": "Evaluation prompted", "input_received": verse_triplets, "hypothesis_vref": None, "hypothesis_key": None}
return backend.execute_discriminator_evaluation(verse_triplets, hypothesis_vref='ROM 1:8')
# @app.websocket("/api/test_feedback_loop")
# async def test_feedback_loop(websocket: WebSocket, vref: str = Query(...), target_language_code: str = Query(...), source_language_code: str = Query(None)):
# await websocket.accept()
# feedback_loop = backend.AILoop(
# iterations=10,
# function_a=lambda: backend.execute_fewshot_translation(vref, target_language_code, source_language_code),
# function_b=backend.execute_discriminator_evaluation,
# )
# for result in feedback_loop:
# await websocket.send_json(result)
# await websocket.close()
@app.get('/api/translate')
def forward_translation_request(vref: str, target_language_code: str):
translation = backend.Translation(vref, target_language_code=target_language_code)
return str({'hypothesis': translation.get_hypothesis(), 'feedback': translation.get_feedback()})
import random
@app.get('/api/get_alignment')
def get_available_alignment(language_code=None, n=10):
# return ../data/alignments/test_spanish.jsonl
code = language_code if language_code else 'test_spanish'
with open(f'data/alignments/{code}.jsonl', 'r') as f:
# note that the data is jsonl, so we need to read it line by line
data = f.readlines()
# Check if n is greater than the length of data
n = min(int(n), len(data))
# Randomly sample n lines from the data
random_indexes = random.sample(range(len(data)), n)
data = [data[i] for i in random_indexes]
# Map over each line and make restructure to match interface expected by frontend
restructured_data = []
for raw_line in data:
line = json.loads(raw_line)
restructured_alignments = []
for alignment in line['alignments']:
keys = list(alignment.keys())
source_key = next((key for key in keys if 'Greek' in key or 'Hebrew' in key), None)
bridge_key = next((key for key in keys if 'English' in key), None)
target_key = next((key for key in keys if key != source_key and key != bridge_key), None)
if source_key and bridge_key and target_key:
restructured_alignments.append({
'source': alignment[source_key],
'bridge': alignment[bridge_key],
'target': alignment[target_key]
})
restructured_data.append({
'vref': line['vref'],
'alignments': restructured_alignments
})
return restructured_data
@app.get('/api/all_alignment_files')
def get_all_alignment_files():
alignment_files = []
def find_jsonl_files(directory):
for root, dirs, files in os.walk(directory):
for file in files:
if file.endswith('.jsonl'):
alignment_files.append(os.path.join(root, file))
find_jsonl_files('data/alignments')
return alignment_files
| [
"lancedb.connect"
] | [((468, 496), 'logging.getLogger', 'logging.getLogger', (['"""uvicorn"""'], {}), "('uvicorn')\n", (485, 496), False, 'import logging\n'), ((504, 513), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (511, 513), False, 'from fastapi import FastAPI, BackgroundTasks, Query, WebSocket, WebSocketDisconnect\n'), ((3201, 3227), 'json.dumps', 'json.dumps', (['verse_triplets'], {}), '(verse_triplets)\n', (3211, 3227), False, 'import os, json, urllib\n'), ((6321, 6501), 'fastapi.responses.FileResponse', 'FileResponse', (['f"""data/bible/{language_code}{file_suffix}.json"""'], {'media_type': '"""application/json"""', 'headers': "{'Content-Disposition': f'attachment; filename={language_code}.json'}"}), "(f'data/bible/{language_code}{file_suffix}.json', media_type=\n 'application/json', headers={'Content-Disposition':\n f'attachment; filename={language_code}.json'})\n", (6333, 6501), False, 'from fastapi.responses import FileResponse\n'), ((6649, 6677), 'lancedb.connect', 'lancedb.connect', (['"""./lancedb"""'], {}), "('./lancedb')\n", (6664, 6677), False, 'import lancedb\n'), ((7356, 7383), 'os.path.exists', 'os.path.exists', (['"""./lancedb"""'], {}), "('./lancedb')\n", (7370, 7383), False, 'import os, json, urllib\n'), ((9292, 9318), 'urllib.parse.unquote', 'urllib.parse.unquote', (['vref'], {}), '(vref)\n', (9312, 9318), False, 'import os, json, urllib\n'), ((4386, 4410), 'os.path.exists', 'os.path.exists', (['filename'], {}), '(filename)\n', (4400, 4410), False, 'import os, json, urllib\n'), ((4441, 4578), 'fastapi.responses.FileResponse', 'FileResponse', (['filename'], {'media_type': '"""application/json"""', 'headers': "{'Content-Disposition': f'attachment; filename={language_code}.json'}"}), "(filename, media_type='application/json', headers={\n 'Content-Disposition': f'attachment; filename={language_code}.json'})\n", (4453, 4578), False, 'from fastapi.responses import FileResponse\n'), ((6066, 6094), 'os.path.exists', 'os.path.exists', (['"""data/bible"""'], {}), "('data/bible')\n", (6080, 6094), False, 'import os, json, urllib\n'), ((6104, 6126), 'os.mkdir', 'os.mkdir', (['"""data/bible"""'], {}), "('data/bible')\n", (6112, 6126), False, 'import os, json, urllib\n'), ((6218, 6268), 'json.dump', 'json.dump', (['output', 'f'], {'ensure_ascii': '(False)', 'indent': '(4)'}), '(output, f, ensure_ascii=False, indent=4)\n', (6227, 6268), False, 'import os, json, urllib\n'), ((7398, 7426), 'lancedb.connect', 'lancedb.connect', (['"""./lancedb"""'], {}), "('./lancedb')\n", (7413, 7426), False, 'import lancedb\n'), ((16777, 16795), 'os.walk', 'os.walk', (['directory'], {}), '(directory)\n', (16784, 16795), False, 'import os, json, urllib\n'), ((15664, 15684), 'json.loads', 'json.loads', (['raw_line'], {}), '(raw_line)\n', (15674, 15684), False, 'import os, json, urllib\n'), ((16915, 16939), 'os.path.join', 'os.path.join', (['root', 'file'], {}), '(root, file)\n', (16927, 16939), False, 'import os, json, urllib\n')] |
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from matplotlib import pyplot as plt
from pandas import DataFrame
from PIL import Image
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
# NOTE: Load the image directly without any resize operations.
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i', returns (im, resized hw)."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f'Image Not Found {f}')
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
return Format(
bbox_format='xyxy',
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(self,
data: Union[str, Path] = 'coco128.yaml',
model: str = 'yolov8n.pt',
uri: str = '~/ultralytics/explorer') -> None:
checks.check_requirements(['lancedb>=0.4.3', 'duckdb'])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + '_' + model.lower()
self.sim_idx_base_name = f'{self.table_name}_sim_idx'.lower(
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = 'train') -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info('Table already exists. Reusing it. Pass force=True to overwrite it.')
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.')
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError('Data must be provided to create embeddings table')
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f'Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}'
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch['im_file'], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode='overwrite')
table.add(
self._yield_batches(dataset,
data_info,
self.model,
exclude_keys=['img', 'ratio_pad', 'resized_shape', 'ori_shape', 'batch_idx']))
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
# Implement Batching
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch['vector'] = model.embed(batch['im_file'], verbose=False)[0].detach().tolist()
yield [batch]
def query(self,
imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
limit: int = 25) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError('Table is not created. Please create the table first.')
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f'img must be a string or a list of strings. Got {type(imgs)}'
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(self,
query: str,
return_type: str = 'pandas') -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in ['pandas',
'arrow'], f'Return type should be either `pandas` or `arrow`, but got {return_type}'
import duckdb
if self.table is None:
raise ValueError('Table is not created. Please create the table first.')
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith('SELECT') and not query.startswith('WHERE'):
raise ValueError(
f'Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}'
)
if query.startswith('WHERE'):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f'Running query: {query}')
rs = duckdb.sql(query)
if return_type == 'pandas':
return rs.df()
elif return_type == 'arrow':
return rs.arrow()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
PIL Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type='arrow')
if len(result) == 0:
LOGGER.info('No results found.')
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = 'pandas') -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
A table or pandas dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in ['pandas',
'arrow'], f'Return type should be either `pandas` or `arrow`, but got {return_type}'
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == 'pandas':
return similar.to_pandas()
elif return_type == 'arrow':
return similar
def plot_similar(self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
PIL Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type='arrow')
if len(similar) == 0:
LOGGER.info('No results found.')
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
A pandas dataframe containing the similarity index.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError('Table is not created. Please create the table first.')
sim_idx_table_name = f'{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}'.lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info('Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.')
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f'top_k must be between 0.0 and 1.0. Got {top_k}')
if max_dist < 0.0:
raise ValueError(f'max_dist must be greater than 0. Got {max_dist}')
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=['vector', 'im_file']).to_pydict()
im_files = features['im_file']
embeddings = features['vector']
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode='overwrite')
def _yield_sim_idx():
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f'_distance <= {max_dist}')
yield [{
'idx': i,
'im_file': im_files[i],
'count': len(sim_idx),
'sim_im_files': sim_idx['im_file'].tolist()}]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
PIL.PngImagePlugin.PngImageFile containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx['count'].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel('data idx')
plt.ylabel('Count')
plt.title('Similarity Count')
buffer = BytesIO()
plt.savefig(buffer, format='png')
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None],
idx: Union[None, int, List[int]]) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError('Either img or idx must be provided.')
if img is not None and idx is not None:
raise ValueError('Only one of img or idx must be provided.')
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=['im_file']).to_pydict()['im_file']
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
Answer from AI.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error('AI generated query is not valid. Please try again with a different prompt')
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query.
Args:
result (arrow table): Arrow table containing the results of a query.
"""
# TODO:
pass
def generate_report(self, result):
"""Generate a report of the dataset."""
pass
| [
"lancedb.connect"
] | [((1642, 1835), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1648, 1835), False, 'from ultralytics.data.augment import Format\n'), ((2137, 2192), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2162, 2192), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2243, 2263), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2258, 2263), False, 'import lancedb\n'), ((2499, 2510), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2503, 2510), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3842, 3870), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3859, 3870), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8431, 8469), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8442, 8469), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((8484, 8501), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8494, 8501), False, 'import duckdb\n'), ((9454, 9474), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9469, 9474), False, 'from PIL import Image\n'), ((12152, 12172), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12167, 12172), False, 'from PIL import Image\n'), ((16115, 16134), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16123, 16134), True, 'import numpy as np\n'), ((16219, 16246), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16226, 16246), True, 'from matplotlib import pyplot as plt\n'), ((16296, 16318), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16306, 16318), True, 'from matplotlib import pyplot as plt\n'), ((16327, 16346), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16337, 16346), True, 'from matplotlib import pyplot as plt\n'), ((16355, 16384), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16364, 16384), True, 'from matplotlib import pyplot as plt\n'), ((16402, 16411), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16409, 16411), False, 'from io import BytesIO\n'), ((16420, 16453), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16431, 16453), True, 'from matplotlib import pyplot as plt\n'), ((3303, 3389), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3314, 3389), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((3491, 3601), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3502, 3601), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((9322, 9354), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9333, 9354), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((12019, 12051), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12030, 12051), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((13473, 13576), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13484, 13576), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((1222, 1233), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1229, 1233), True, 'import numpy as np\n'), ((1287, 1300), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1297, 1300), False, 'import cv2\n'), ((16573, 16591), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16583, 16591), False, 'from PIL import Image\n'), ((17761, 17860), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (17773, 17860), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((17863, 17878), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (17875, 17878), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2290, 2300), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2294, 2300), False, 'from pathlib import Path\n'), ((6655, 6674), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6666, 6674), False, 'import torch\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.legacy_filters():
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text or "", # ensure text is a string
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2782, 2802), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2797, 2802), False, 'import lancedb\n'), ((1179, 1208), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1185, 1208), True, 'import numpy as np\n'), ((3214, 3293), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=True, flat_metadata=self.flat_metadata)\n', (3235, 3293), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((1089, 1113), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1095, 1113), True, 'import numpy as np\n'), ((5548, 5584), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5563, 5584), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self,
data: Union[str, Path] = "coco128.yaml",
model: str = "yolov8n.pt",
uri: str = USER_CONFIG_DIR / "explorer",
) -> None:
# Note duckdb==0.10.0 bug https://github.com/ultralytics/ultralytics/pull/8181
checks.check_requirements(["lancedb>=0.4.3", "duckdb<=0.9.2"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1697, 1890), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1703, 1890), False, 'from ultralytics.data.augment import Format\n'), ((2270, 2332), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb<=0.9.2']"], {}), "(['lancedb>=0.4.3', 'duckdb<=0.9.2'])\n", (2295, 2332), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2383, 2403), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2398, 2403), False, 'import lancedb\n'), ((2654, 2665), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2658, 2665), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3997, 4025), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (4014, 4025), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8632, 8670), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8643, 8670), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((8685, 8702), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8695, 8702), False, 'import duckdb\n'), ((9664, 9684), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9679, 9684), False, 'from PIL import Image\n'), ((12309, 12329), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12324, 12329), False, 'from PIL import Image\n'), ((16581, 16600), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16589, 16600), True, 'import numpy as np\n'), ((16685, 16712), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16692, 16712), True, 'from matplotlib import pyplot as plt\n'), ((16762, 16784), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16772, 16784), True, 'from matplotlib import pyplot as plt\n'), ((16793, 16812), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16803, 16812), True, 'from matplotlib import pyplot as plt\n'), ((16821, 16850), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16830, 16850), True, 'from matplotlib import pyplot as plt\n'), ((16868, 16877), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16875, 16877), False, 'from io import BytesIO\n'), ((16886, 16919), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16897, 16919), True, 'from matplotlib import pyplot as plt\n'), ((3458, 3544), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3469, 3544), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((3646, 3756), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3657, 3756), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((9532, 9564), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9543, 9564), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((12176, 12208), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12187, 12208), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((13786, 13889), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13797, 13889), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((1207, 1218), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1214, 1218), True, 'import numpy as np\n'), ((1272, 1285), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1282, 1285), False, 'import cv2\n'), ((17039, 17057), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (17049, 17057), False, 'from PIL import Image\n'), ((18275, 18374), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18287, 18374), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((18377, 18392), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18389, 18392), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2430, 2440), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2434, 2440), False, 'from pathlib import Path\n'), ((6857, 6876), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6868, 6876), False, 'import torch\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self,
data: Union[str, Path] = "coco128.yaml",
model: str = "yolov8n.pt",
uri: str = USER_CONFIG_DIR / "explorer",
) -> None:
# Note duckdb==0.10.0 bug https://github.com/ultralytics/ultralytics/pull/8181
checks.check_requirements(["lancedb>=0.4.3", "duckdb<=0.9.2"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1697, 1890), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1703, 1890), False, 'from ultralytics.data.augment import Format\n'), ((2270, 2332), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb<=0.9.2']"], {}), "(['lancedb>=0.4.3', 'duckdb<=0.9.2'])\n", (2295, 2332), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2383, 2403), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2398, 2403), False, 'import lancedb\n'), ((2654, 2665), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2658, 2665), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3997, 4025), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (4014, 4025), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8632, 8670), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8643, 8670), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((8685, 8702), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8695, 8702), False, 'import duckdb\n'), ((9664, 9684), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9679, 9684), False, 'from PIL import Image\n'), ((12309, 12329), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12324, 12329), False, 'from PIL import Image\n'), ((16581, 16600), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16589, 16600), True, 'import numpy as np\n'), ((16685, 16712), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16692, 16712), True, 'from matplotlib import pyplot as plt\n'), ((16762, 16784), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16772, 16784), True, 'from matplotlib import pyplot as plt\n'), ((16793, 16812), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16803, 16812), True, 'from matplotlib import pyplot as plt\n'), ((16821, 16850), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16830, 16850), True, 'from matplotlib import pyplot as plt\n'), ((16868, 16877), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16875, 16877), False, 'from io import BytesIO\n'), ((16886, 16919), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16897, 16919), True, 'from matplotlib import pyplot as plt\n'), ((3458, 3544), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3469, 3544), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((3646, 3756), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3657, 3756), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((9532, 9564), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9543, 9564), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((12176, 12208), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12187, 12208), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((13786, 13889), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13797, 13889), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((1207, 1218), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1214, 1218), True, 'import numpy as np\n'), ((1272, 1285), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1282, 1285), False, 'import cv2\n'), ((17039, 17057), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (17049, 17057), False, 'from PIL import Image\n'), ((18275, 18374), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18287, 18374), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((18377, 18392), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18389, 18392), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2430, 2440), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2434, 2440), False, 'from pathlib import Path\n'), ((6857, 6876), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6868, 6876), False, 'import torch\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self,
data: Union[str, Path] = "coco128.yaml",
model: str = "yolov8n.pt",
uri: str = USER_CONFIG_DIR / "explorer",
) -> None:
# Note duckdb==0.10.0 bug https://github.com/ultralytics/ultralytics/pull/8181
checks.check_requirements(["lancedb>=0.4.3", "duckdb<=0.9.2"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1697, 1890), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1703, 1890), False, 'from ultralytics.data.augment import Format\n'), ((2270, 2332), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb<=0.9.2']"], {}), "(['lancedb>=0.4.3', 'duckdb<=0.9.2'])\n", (2295, 2332), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2383, 2403), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2398, 2403), False, 'import lancedb\n'), ((2654, 2665), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2658, 2665), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3997, 4025), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (4014, 4025), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8632, 8670), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8643, 8670), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((8685, 8702), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8695, 8702), False, 'import duckdb\n'), ((9664, 9684), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9679, 9684), False, 'from PIL import Image\n'), ((12309, 12329), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12324, 12329), False, 'from PIL import Image\n'), ((16581, 16600), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16589, 16600), True, 'import numpy as np\n'), ((16685, 16712), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16692, 16712), True, 'from matplotlib import pyplot as plt\n'), ((16762, 16784), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16772, 16784), True, 'from matplotlib import pyplot as plt\n'), ((16793, 16812), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16803, 16812), True, 'from matplotlib import pyplot as plt\n'), ((16821, 16850), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16830, 16850), True, 'from matplotlib import pyplot as plt\n'), ((16868, 16877), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16875, 16877), False, 'from io import BytesIO\n'), ((16886, 16919), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16897, 16919), True, 'from matplotlib import pyplot as plt\n'), ((3458, 3544), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3469, 3544), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((3646, 3756), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3657, 3756), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((9532, 9564), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9543, 9564), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((12176, 12208), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12187, 12208), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((13786, 13889), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13797, 13889), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((1207, 1218), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1214, 1218), True, 'import numpy as np\n'), ((1272, 1285), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1282, 1285), False, 'import cv2\n'), ((17039, 17057), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (17049, 17057), False, 'from PIL import Image\n'), ((18275, 18374), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18287, 18374), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((18377, 18392), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18389, 18392), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2430, 2440), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2434, 2440), False, 'from pathlib import Path\n'), ((6857, 6876), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6868, 6876), False, 'import torch\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self,
data: Union[str, Path] = "coco128.yaml",
model: str = "yolov8n.pt",
uri: str = USER_CONFIG_DIR / "explorer",
) -> None:
# Note duckdb==0.10.0 bug https://github.com/ultralytics/ultralytics/pull/8181
checks.check_requirements(["lancedb>=0.4.3", "duckdb<=0.9.2"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1697, 1890), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1703, 1890), False, 'from ultralytics.data.augment import Format\n'), ((2270, 2332), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb<=0.9.2']"], {}), "(['lancedb>=0.4.3', 'duckdb<=0.9.2'])\n", (2295, 2332), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2383, 2403), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2398, 2403), False, 'import lancedb\n'), ((2654, 2665), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2658, 2665), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3997, 4025), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (4014, 4025), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8632, 8670), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8643, 8670), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((8685, 8702), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8695, 8702), False, 'import duckdb\n'), ((9664, 9684), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9679, 9684), False, 'from PIL import Image\n'), ((12309, 12329), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12324, 12329), False, 'from PIL import Image\n'), ((16581, 16600), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16589, 16600), True, 'import numpy as np\n'), ((16685, 16712), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16692, 16712), True, 'from matplotlib import pyplot as plt\n'), ((16762, 16784), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16772, 16784), True, 'from matplotlib import pyplot as plt\n'), ((16793, 16812), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16803, 16812), True, 'from matplotlib import pyplot as plt\n'), ((16821, 16850), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16830, 16850), True, 'from matplotlib import pyplot as plt\n'), ((16868, 16877), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16875, 16877), False, 'from io import BytesIO\n'), ((16886, 16919), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16897, 16919), True, 'from matplotlib import pyplot as plt\n'), ((3458, 3544), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3469, 3544), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((3646, 3756), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3657, 3756), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((9532, 9564), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9543, 9564), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((12176, 12208), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12187, 12208), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((13786, 13889), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13797, 13889), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((1207, 1218), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1214, 1218), True, 'import numpy as np\n'), ((1272, 1285), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1282, 1285), False, 'import cv2\n'), ((17039, 17057), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (17049, 17057), False, 'from PIL import Image\n'), ((18275, 18374), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18287, 18374), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((18377, 18392), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18389, 18392), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2430, 2440), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2434, 2440), False, 'from pathlib import Path\n'), ((6857, 6876), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6868, 6876), False, 'import torch\n')] |
"""LanceDB vector store."""
import logging
from typing import Any, List, Optional
import numpy as np
from llama_index.core.bridge.pydantic import PrivateAttr
from llama_index.core.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.core.vector_stores.types import (
MetadataFilters,
BasePydanticVectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.core.vector_stores.utils import (
DEFAULT_DOC_ID_KEY,
DEFAULT_TEXT_KEY,
legacy_metadata_dict_to_node,
metadata_dict_to_node,
node_to_metadata_dict,
)
from pandas import DataFrame
import lancedb
_logger = logging.getLogger(__name__)
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.legacy_filters():
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(BasePydanticVectorStore):
"""
The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
vector_column_name (str, optional): The vector column name in the table if different from default.
Defaults to "vector", in keeping with lancedb convention.
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
_connection: Any = PrivateAttr()
uri: Optional[str]
table_name: Optional[str]
vector_column_name: Optional[str]
nprobes: Optional[int]
refine_factor: Optional[int]
text_key: Optional[str]
doc_id_key: Optional[str]
def __init__(
self,
uri: Optional[str],
table_name: str = "vectors",
vector_column_name: str = "vector",
nprobes: int = 20,
refine_factor: Optional[int] = None,
text_key: str = DEFAULT_TEXT_KEY,
doc_id_key: str = DEFAULT_DOC_ID_KEY,
**kwargs: Any,
) -> None:
"""Init params."""
self._connection = lancedb.connect(uri)
super().__init__(
uri=uri,
table_name=table_name,
vector_column_name=vector_column_name,
nprobes=nprobes,
refine_factor=refine_factor,
text_key=text_key,
doc_id_key=doc_id_key,
**kwargs,
)
@property
def client(self) -> None:
"""Get client."""
return self._connection
@classmethod
def from_params(
cls,
uri: Optional[str],
table_name: str = "vectors",
vector_column_name: str = "vector",
nprobes: int = 20,
refine_factor: Optional[int] = None,
text_key: str = DEFAULT_TEXT_KEY,
doc_id_key: str = DEFAULT_DOC_ID_KEY,
**kwargs: Any,
) -> "LanceDBVectorStore":
"""Create instance from params."""
_connection_ = cls._connection
return cls(
_connection=_connection_,
uri=uri,
table_name=table_name,
vector_column_name=vector_column_name,
nprobes=nprobes,
refine_factor=refine_factor,
text_key=text_key,
doc_id_key=doc_id_key,
**kwargs,
)
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
if not nodes:
_logger.debug("No nodes to add. Skipping the database operation.")
return []
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=False, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
"metadata": metadata,
}
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self._connection.table_names():
tbl = self._connection.open_table(self.table_name)
tbl.add(data)
else:
self._connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self._connection.open_table(self.table_name)
table.delete('doc_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self._connection.open_table(self.table_name)
lance_query = (
table.search(
query=query.query_embedding,
vector_column_name=self.vector_column_name,
)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_pandas()
nodes = []
for _, item in results.iterrows():
try:
node = metadata_dict_to_node(item.metadata)
node.embedding = list(item[self.vector_column_name])
except Exception:
# deprecated legacy logic for backward compatibility
_logger.debug(
"Failed to parse Node metadata, fallback to legacy logic."
)
if "metadata" in item:
metadata, node_info, _relation = legacy_metadata_dict_to_node(
item.metadata, text_key=self.text_key
)
else:
metadata, node_info = {}, {}
node = TextNode(
text=item[self.text_key] or "",
id_=item.id,
metadata=metadata,
start_char_idx=node_info.get("start", None),
end_char_idx=node_info.get("end", None),
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(
node_id=item[self.doc_id_key]
),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((685, 712), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (702, 712), False, 'import logging\n'), ((2814, 2827), 'llama_index.core.bridge.pydantic.PrivateAttr', 'PrivateAttr', ([], {}), '()\n', (2825, 2827), False, 'from llama_index.core.bridge.pydantic import PrivateAttr\n'), ((3431, 3451), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (3446, 3451), False, 'import lancedb\n'), ((1449, 1478), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1455, 1478), True, 'import numpy as np\n'), ((4960, 5045), 'llama_index.core.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(False)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=False, flat_metadata=self.flat_metadata\n )\n', (4981, 5045), False, 'from llama_index.core.vector_stores.utils import DEFAULT_DOC_ID_KEY, DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((1359, 1383), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1365, 1383), True, 'import numpy as np\n'), ((7233, 7269), 'llama_index.core.vector_stores.utils.metadata_dict_to_node', 'metadata_dict_to_node', (['item.metadata'], {}), '(item.metadata)\n', (7254, 7269), False, 'from llama_index.core.vector_stores.utils import DEFAULT_DOC_ID_KEY, DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((7658, 7725), 'llama_index.core.vector_stores.utils.legacy_metadata_dict_to_node', 'legacy_metadata_dict_to_node', (['item.metadata'], {'text_key': 'self.text_key'}), '(item.metadata, text_key=self.text_key)\n', (7686, 7725), False, 'from llama_index.core.vector_stores.utils import DEFAULT_DOC_ID_KEY, DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((8211, 8257), 'llama_index.core.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item[self.doc_id_key]'}), '(node_id=item[self.doc_id_key])\n', (8226, 8257), False, 'from llama_index.core.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
from openai import OpenAI
import streamlit as st
import os
from trubrics import Trubrics
import lancedb
from langchain_community.vectorstores import LanceDB
from langchain_openai import OpenAIEmbeddings
from langchain_openai import ChatOpenAI
from langchain_community.callbacks import TrubricsCallbackHandler
import os
import time
os.environ["OPENAI_API_KEY"] = st.secrets["OPENAI_API_KEY"]
os.environ["TRUBRICS_EMAIL"] = st.secrets["TRUBRICS_EMAIL"]
os.environ["TRUBRICS_PASSWORD"] = st.secrets["TRUBRICS_PASSWORD"]
db = lancedb.connect("/mnt/d/LLM-Project/my-app/lancedb_meta_data")
table = db.open_table("EIC_archive")
embeddings = OpenAIEmbeddings()
vectorstore = LanceDB(connection = table, embedding = embeddings)
retriever = vectorstore.as_retriever(search_type = "similarity", search_kwargs={"k" : 100})
with st.sidebar:
with st.form("User Name"):
st.info("By providing you name, you agree that all the prompts and responses will be recorded and will be used to further improve RAG methods")
name = st.text_input("What's your name?")
submitted = st.form_submit_button("Submit and start")
if submitted:
for key in st.session_state:
del st.session_state[key]
st.session_state["user_name"] = name
if "user_name" not in st.session_state:
st.stop()
llm = ChatOpenAI(model_name="gpt-3.5-turbo-1106", temperature=0,
callbacks=[
TrubricsCallbackHandler(
project="EIC-RAG-TestRun",
tags = ["EIC-RAG-TestRun"],
user_id = st.session_state["user_name"],
)
],
max_tokens=4096)
from langchain.schema import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough
def format_docs(docs):
return f"\n\n".join(f'{i+1}. ' + doc.page_content.strip("\n") + f"<ARXIV_ID> {doc.metadata['arxiv_id']} <ARXIV_ID/>" for i, doc in enumerate(docs))
from langchain.prompts import PromptTemplate
response = """\
You are an expert in providing up to date information about the Electron Ion Collider (EIC), tasked with answering any question. You greet people when greeted. \
about EIC based only on the provided context. You shall strictly not answer questions anything other than EIC related questions. \
Refrain any other topics by saying you will not answer questions about them and Exit right away here. DO NOT PROCEED. \
You are not allowed to use any other sources other than the provided search results. \
Generate a comprehensive, and informative answer strictly within 200 words or less for the \
given question based solely on the provided search results (URL and content). You must \
only use information from the provided search results. Use an unbiased and \
journalistic tone. Combine search results together into a coherent answer. Do not \
repeat text. You should use bullet points in your answer for readability. Make sure to break down your answer into bullet points.\
You should not hallicunate nor build up any references, Use only the `context` html block below and do not use any text within <ARXIV_ID> and </ARXIV_ID> except when citing in the end.
Make sure not to repeat the same context. Be specific to the exact question asked for.\
Here is the response template:
---
# Response template
- Start with a greeting and a summary of the user's query
- Use bullet points to list the main points or facts that answer the query using the information within the tags <context> and <context/>.
- After answering, analyze the respective source links provided within <ARXIV_ID> and </ARXIV_ID> and keep only the unique links for the next step. Try to minimize the total number of unique links with no more than 10 unique links for the answer.
- You will strictly use no more than 10 most unique links for the answer.
- Use bulleted list of superscript numbers within square brackets to cite the sources for each point or fact. The numbers should correspond to the order of the sources which will be provided in the end of this reponse. Note that for every source, you must provide a URL.
- End with a closing remark and a list of sources with their respective URLs as a bullet list explicitly with full links which are enclosed in the tag <ARXIV_ID> and </ARXIV_ID> respectively.\
---
Here is how an response would look like. Reproduce the same format for your response:
---
# Example response
Hello, thank you for your question about Retrieval Augmented Generation. Here are some key points about RAG:
- Retrieval Augmented Generation is a technique that combines the strengths of pre-trained language models and information retrieval systems to generate responses or content by leveraging external knowledge[^1^] [^2^]
- RAG can be useful when the pre-trained language model alone may not have the necessary information to generate accurate or sufficiently detailed responses, since standard language models like GPT-4 are not capable of accessing real-time or post-training external information directly[^1^] [^3^]
- RAG uses a vector database such as Milvus to index and retrieve relevant documents or text snippets from a knowledge source, and provides them as additional context for the language model[^4^] [^5^]
- RAG can benefit from adding citations to the generated outputs, as it can improve their factual correctness, verifiability, and trustworthiness[^6^] [^7^]
I hope this helps you understand more about RAG.
## Sources
* [^1^][1]: http://arxiv.org/abs/2308.03393v1
* [^2^][2]: http://arxiv.org/abs/2308.03393v1
* [^3^][3]: http://arxiv.org/abs/2307.08593v1
* [^4^][4]: http://arxiv.org/abs/2202.05981v2
* [^5^][5]: http://arxiv.org/abs/2210.09287v1
* [^6^][6]: http://arxiv.org/abs/2242.05981v2
* [^7^][7]: http://arxiv.org/abs/2348.05293v1
---
Where each of the references are taken from the corresponding <ARXIV_ID> in the context. Strictly do not provide title for the references \
Strictly do not repeat the same links. Use the numbers to cite the sources. \
If there is nothing in the context relevant to the question at hand, just say "Hmm, \
I'm not sure." or greet back. Don't try to make up an answer. Write the answer in the form of markdown bullet points.\
Make sure to highlight the most important key words in bold font. Dot repeat any context nor points in the answer.\
Anything between the following `context` html blocks is retrieved from a knowledge \
bank, not part of the conversation with the user. The context are numbered based on its knowledge retrival and increasing cosine similarity index. \
Make sure to consider the order in which they appear context appear. It is an increasing order of cosine similarity index.\
The contents are formatted in latex, you need to remove any special characters and latex formatting before cohercing the points to build your answer.\
Write your answer in the form of markdown bullet points. You can use latex commands if necessary.
You will strictly cite no more than 10 unqiue citations at maximum from the context below.\
Make sure these citations have to be relavant and strictly do not repeat the context in the answer.
<context>
{context}
<context/>
REMEMBER: If there is no relevant information within the context, just say "Hmm, I'm \
not sure." or greet back. Don't try to make up an answer. Anything between the preceding 'context' \
html blocks is retrieved from a knowledge bank, not part of the conversation with the \
user.\
Question: {question}
"""
rag_prompt_custom = PromptTemplate.from_template(response)
from operator import itemgetter
from langchain.schema.runnable import RunnableMap
rag_chain_from_docs = (
{
"context": lambda input: format_docs(input["documents"]),
"question": itemgetter("question"),
}
| rag_prompt_custom
| llm
| StrOutputParser()
)
rag_chain_with_source = RunnableMap(
{"documents": retriever, "question": RunnablePassthrough()}
) | {
"answer": rag_chain_from_docs,
}
st.warning("This project is being continuously developed. Please report any feedback to [email protected]")
col1, col2 = st.columns(2)
with col1:
st.image("https://indico.bnl.gov/event/19560/logo-410523303.png")
with col2:
st.title("AI4EIC Agent")
st.sidebar.title("Data Collection")
if "openai_model" not in st.session_state:
st.session_state["openai_model"] = "gpt-3.5-turbo"
if "messages" not in st.session_state:
st.session_state.messages = []
for message in st.session_state.messages:
with st.chat_message(message["role"]):
st.markdown(message["content"])
if prompt := st.chat_input("What is up?"):
st.session_state.messages.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
full_response = ""
allchunks = None
with st.spinner("Gathering info from Knowledge Bank and writing response..."):
allchunks = rag_chain_with_source.stream(prompt)
message_placeholder = st.empty()
for chunk in allchunks:
full_response += (chunk.get("answer") or "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.messages.append({"role": "assistant", "content": full_response})
| [
"lancedb.connect"
] | [((526, 588), 'lancedb.connect', 'lancedb.connect', (['"""/mnt/d/LLM-Project/my-app/lancedb_meta_data"""'], {}), "('/mnt/d/LLM-Project/my-app/lancedb_meta_data')\n", (541, 588), False, 'import lancedb\n'), ((639, 657), 'langchain_openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (655, 657), False, 'from langchain_openai import OpenAIEmbeddings\n'), ((672, 719), 'langchain_community.vectorstores.LanceDB', 'LanceDB', ([], {'connection': 'table', 'embedding': 'embeddings'}), '(connection=table, embedding=embeddings)\n', (679, 719), False, 'from langchain_community.vectorstores import LanceDB\n'), ((7605, 7643), 'langchain.prompts.PromptTemplate.from_template', 'PromptTemplate.from_template', (['response'], {}), '(response)\n', (7633, 7643), False, 'from langchain.prompts import PromptTemplate\n'), ((8080, 8196), 'streamlit.warning', 'st.warning', (['"""This project is being continuously developed. Please report any feedback to [email protected]"""'], {}), "(\n 'This project is being continuously developed. Please report any feedback to [email protected]'\n )\n", (8090, 8196), True, 'import streamlit as st\n'), ((8201, 8214), 'streamlit.columns', 'st.columns', (['(2)'], {}), '(2)\n', (8211, 8214), True, 'import streamlit as st\n'), ((8337, 8372), 'streamlit.sidebar.title', 'st.sidebar.title', (['"""Data Collection"""'], {}), "('Data Collection')\n", (8353, 8372), True, 'import streamlit as st\n'), ((1329, 1338), 'streamlit.stop', 'st.stop', ([], {}), '()\n', (1336, 1338), True, 'import streamlit as st\n'), ((7915, 7932), 'langchain.schema.StrOutputParser', 'StrOutputParser', ([], {}), '()\n', (7930, 7932), False, 'from langchain.schema import StrOutputParser\n'), ((8230, 8295), 'streamlit.image', 'st.image', (['"""https://indico.bnl.gov/event/19560/logo-410523303.png"""'], {}), "('https://indico.bnl.gov/event/19560/logo-410523303.png')\n", (8238, 8295), True, 'import streamlit as st\n'), ((8311, 8335), 'streamlit.title', 'st.title', (['"""AI4EIC Agent"""'], {}), "('AI4EIC Agent')\n", (8319, 8335), True, 'import streamlit as st\n'), ((8687, 8715), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (8700, 8715), True, 'import streamlit as st\n'), ((8721, 8790), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (8753, 8790), True, 'import streamlit as st\n'), ((9361, 9446), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content':\n full_response})\n", (9393, 9446), True, 'import streamlit as st\n'), ((844, 864), 'streamlit.form', 'st.form', (['"""User Name"""'], {}), "('User Name')\n", (851, 864), True, 'import streamlit as st\n'), ((874, 1027), 'streamlit.info', 'st.info', (['"""By providing you name, you agree that all the prompts and responses will be recorded and will be used to further improve RAG methods"""'], {}), "(\n 'By providing you name, you agree that all the prompts and responses will be recorded and will be used to further improve RAG methods'\n )\n", (881, 1027), True, 'import streamlit as st\n'), ((1033, 1067), 'streamlit.text_input', 'st.text_input', (['"""What\'s your name?"""'], {}), '("What\'s your name?")\n', (1046, 1067), True, 'import streamlit as st\n'), ((1088, 1129), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""Submit and start"""'], {}), "('Submit and start')\n", (1109, 1129), True, 'import streamlit as st\n'), ((8599, 8631), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (8614, 8631), True, 'import streamlit as st\n'), ((8641, 8672), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (8652, 8672), True, 'import streamlit as st\n'), ((8800, 8823), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (8815, 8823), True, 'import streamlit as st\n'), ((8833, 8852), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (8844, 8852), True, 'import streamlit as st\n'), ((8863, 8891), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (8878, 8891), True, 'import streamlit as st\n'), ((1455, 1574), 'langchain_community.callbacks.TrubricsCallbackHandler', 'TrubricsCallbackHandler', ([], {'project': '"""EIC-RAG-TestRun"""', 'tags': "['EIC-RAG-TestRun']", 'user_id': "st.session_state['user_name']"}), "(project='EIC-RAG-TestRun', tags=['EIC-RAG-TestRun'],\n user_id=st.session_state['user_name'])\n", (1478, 1574), False, 'from langchain_community.callbacks import TrubricsCallbackHandler\n'), ((8013, 8034), 'langchain.schema.runnable.RunnablePassthrough', 'RunnablePassthrough', ([], {}), '()\n', (8032, 8034), False, 'from langchain.schema.runnable import RunnablePassthrough\n'), ((8958, 9030), 'streamlit.spinner', 'st.spinner', (['"""Gathering info from Knowledge Bank and writing response..."""'], {}), "('Gathering info from Knowledge Bank and writing response...')\n", (8968, 9030), True, 'import streamlit as st\n'), ((9127, 9137), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (9135, 9137), True, 'import streamlit as st\n'), ((7845, 7867), 'operator.itemgetter', 'itemgetter', (['"""question"""'], {}), "('question')\n", (7855, 7867), False, 'from operator import itemgetter\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self,
data: Union[str, Path] = "coco128.yaml",
model: str = "yolov8n.pt",
uri: str = USER_CONFIG_DIR / "explorer",
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1697, 1890), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1703, 1890), False, 'from ultralytics.data.augment import Format\n'), ((2183, 2238), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2208, 2238), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2289, 2309), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2304, 2309), False, 'import lancedb\n'), ((2560, 2571), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2564, 2571), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3903, 3931), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3920, 3931), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8538, 8576), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8549, 8576), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((8591, 8608), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8601, 8608), False, 'import duckdb\n'), ((9570, 9590), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9585, 9590), False, 'from PIL import Image\n'), ((12215, 12235), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12230, 12235), False, 'from PIL import Image\n'), ((16487, 16506), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16495, 16506), True, 'import numpy as np\n'), ((16591, 16618), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16598, 16618), True, 'from matplotlib import pyplot as plt\n'), ((16668, 16690), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16678, 16690), True, 'from matplotlib import pyplot as plt\n'), ((16699, 16718), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16709, 16718), True, 'from matplotlib import pyplot as plt\n'), ((16727, 16756), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16736, 16756), True, 'from matplotlib import pyplot as plt\n'), ((16774, 16783), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16781, 16783), False, 'from io import BytesIO\n'), ((16792, 16825), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16803, 16825), True, 'from matplotlib import pyplot as plt\n'), ((3364, 3450), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3375, 3450), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((3552, 3662), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3563, 3662), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((9438, 9470), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9449, 9470), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((12082, 12114), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12093, 12114), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((13692, 13795), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13703, 13795), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((1207, 1218), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1214, 1218), True, 'import numpy as np\n'), ((1272, 1285), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1282, 1285), False, 'import cv2\n'), ((16945, 16963), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16955, 16963), False, 'from PIL import Image\n'), ((18181, 18280), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18193, 18280), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((18283, 18298), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18295, 18298), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2336, 2346), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2340, 2346), False, 'from pathlib import Path\n'), ((6763, 6782), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6774, 6782), False, 'import torch\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self,
data: Union[str, Path] = "coco128.yaml",
model: str = "yolov8n.pt",
uri: str = USER_CONFIG_DIR / "explorer",
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1697, 1890), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1703, 1890), False, 'from ultralytics.data.augment import Format\n'), ((2183, 2238), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2208, 2238), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2289, 2309), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2304, 2309), False, 'import lancedb\n'), ((2560, 2571), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2564, 2571), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3903, 3931), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3920, 3931), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8538, 8576), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8549, 8576), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((8591, 8608), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8601, 8608), False, 'import duckdb\n'), ((9570, 9590), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9585, 9590), False, 'from PIL import Image\n'), ((12215, 12235), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12230, 12235), False, 'from PIL import Image\n'), ((16487, 16506), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16495, 16506), True, 'import numpy as np\n'), ((16591, 16618), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16598, 16618), True, 'from matplotlib import pyplot as plt\n'), ((16668, 16690), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16678, 16690), True, 'from matplotlib import pyplot as plt\n'), ((16699, 16718), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16709, 16718), True, 'from matplotlib import pyplot as plt\n'), ((16727, 16756), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16736, 16756), True, 'from matplotlib import pyplot as plt\n'), ((16774, 16783), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16781, 16783), False, 'from io import BytesIO\n'), ((16792, 16825), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16803, 16825), True, 'from matplotlib import pyplot as plt\n'), ((3364, 3450), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3375, 3450), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((3552, 3662), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3563, 3662), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((9438, 9470), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9449, 9470), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((12082, 12114), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12093, 12114), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((13692, 13795), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13703, 13795), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((1207, 1218), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1214, 1218), True, 'import numpy as np\n'), ((1272, 1285), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1282, 1285), False, 'import cv2\n'), ((16945, 16963), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16955, 16963), False, 'from PIL import Image\n'), ((18181, 18280), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18193, 18280), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((18283, 18298), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18295, 18298), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2336, 2346), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2340, 2346), False, 'from pathlib import Path\n'), ((6763, 6782), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6774, 6782), False, 'import torch\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self,
data: Union[str, Path] = "coco128.yaml",
model: str = "yolov8n.pt",
uri: str = USER_CONFIG_DIR / "explorer",
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1697, 1890), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1703, 1890), False, 'from ultralytics.data.augment import Format\n'), ((2183, 2238), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2208, 2238), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2289, 2309), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2304, 2309), False, 'import lancedb\n'), ((2560, 2571), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2564, 2571), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3903, 3931), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3920, 3931), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8538, 8576), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8549, 8576), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((8591, 8608), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8601, 8608), False, 'import duckdb\n'), ((9570, 9590), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9585, 9590), False, 'from PIL import Image\n'), ((12215, 12235), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12230, 12235), False, 'from PIL import Image\n'), ((16487, 16506), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16495, 16506), True, 'import numpy as np\n'), ((16591, 16618), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16598, 16618), True, 'from matplotlib import pyplot as plt\n'), ((16668, 16690), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16678, 16690), True, 'from matplotlib import pyplot as plt\n'), ((16699, 16718), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16709, 16718), True, 'from matplotlib import pyplot as plt\n'), ((16727, 16756), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16736, 16756), True, 'from matplotlib import pyplot as plt\n'), ((16774, 16783), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16781, 16783), False, 'from io import BytesIO\n'), ((16792, 16825), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16803, 16825), True, 'from matplotlib import pyplot as plt\n'), ((3364, 3450), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3375, 3450), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((3552, 3662), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3563, 3662), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((9438, 9470), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9449, 9470), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((12082, 12114), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12093, 12114), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((13692, 13795), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13703, 13795), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((1207, 1218), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1214, 1218), True, 'import numpy as np\n'), ((1272, 1285), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1282, 1285), False, 'import cv2\n'), ((16945, 16963), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16955, 16963), False, 'from PIL import Image\n'), ((18181, 18280), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18193, 18280), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((18283, 18298), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18295, 18298), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2336, 2346), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2340, 2346), False, 'from pathlib import Path\n'), ((6763, 6782), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6774, 6782), False, 'import torch\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
from llama_index.data_structs.node import DocumentRelationship, Node
from llama_index.vector_stores.types import (
NodeWithEmbedding,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb # noqa: F401
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return None
def add(
self,
embedding_results: List[NodeWithEmbedding],
) -> List[str]:
data = []
ids = []
for result in embedding_results:
data.append(
{
"id": result.id,
"doc_id": result.ref_doc_id,
"vector": result.embedding,
"text": result.node.get_text(),
}
)
ids.append(result.id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
raise NotImplementedError("Delete not yet implemented for LanceDB.")
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
raise ValueError("Metadata filters not implemented for LanceDB yet.")
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = Node(
doc_id=item.id,
text=item.text,
relationships={
DocumentRelationship.SOURCE: item.doc_id,
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=results["score"].tolist(),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((1711, 1731), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (1726, 1731), False, 'import lancedb\n'), ((3712, 3811), 'llama_index.data_structs.node.Node', 'Node', ([], {'doc_id': 'item.id', 'text': 'item.text', 'relationships': '{DocumentRelationship.SOURCE: item.doc_id}'}), '(doc_id=item.id, text=item.text, relationships={DocumentRelationship.\n SOURCE: item.doc_id})\n', (3716, 3811), False, 'from llama_index.data_structs.node import DocumentRelationship, Node\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
from llama_index.data_structs.node import DocumentRelationship, Node
from llama_index.vector_stores.types import (
NodeWithEmbedding,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb # noqa: F401
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return None
def add(
self,
embedding_results: List[NodeWithEmbedding],
) -> List[str]:
data = []
ids = []
for result in embedding_results:
data.append(
{
"id": result.id,
"doc_id": result.ref_doc_id,
"vector": result.embedding,
"text": result.node.get_text(),
}
)
ids.append(result.id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
raise NotImplementedError("Delete not yet implemented for LanceDB.")
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
raise ValueError("Metadata filters not implemented for LanceDB yet.")
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = Node(
doc_id=item.id,
text=item.text,
relationships={
DocumentRelationship.SOURCE: item.doc_id,
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=results["score"].tolist(),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((1711, 1731), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (1726, 1731), False, 'import lancedb\n'), ((3712, 3811), 'llama_index.data_structs.node.Node', 'Node', ([], {'doc_id': 'item.id', 'text': 'item.text', 'relationships': '{DocumentRelationship.SOURCE: item.doc_id}'}), '(doc_id=item.id, text=item.text, relationships={DocumentRelationship.\n SOURCE: item.doc_id})\n', (3716, 3811), False, 'from llama_index.data_structs.node import DocumentRelationship, Node\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self, data: Union[str, Path] = "coco128.yaml", model: str = "yolov8n.pt", uri: str = "~/ultralytics/explorer"
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1680, 1873), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1686, 1873), False, 'from ultralytics.data.augment import Format\n'), ((2137, 2192), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2162, 2192), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2243, 2263), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2258, 2263), False, 'import lancedb\n'), ((2514, 2525), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2518, 2525), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3857, 3885), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3874, 3885), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8492, 8530), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8503, 8530), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((8545, 8562), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8555, 8562), False, 'import duckdb\n'), ((9524, 9544), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9539, 9544), False, 'from PIL import Image\n'), ((12169, 12189), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12184, 12189), False, 'from PIL import Image\n'), ((16441, 16460), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16449, 16460), True, 'import numpy as np\n'), ((16545, 16572), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16552, 16572), True, 'from matplotlib import pyplot as plt\n'), ((16622, 16644), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16632, 16644), True, 'from matplotlib import pyplot as plt\n'), ((16653, 16672), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16663, 16672), True, 'from matplotlib import pyplot as plt\n'), ((16681, 16710), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16690, 16710), True, 'from matplotlib import pyplot as plt\n'), ((16728, 16737), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16735, 16737), False, 'from io import BytesIO\n'), ((16746, 16779), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16757, 16779), True, 'from matplotlib import pyplot as plt\n'), ((3318, 3404), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3329, 3404), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((3506, 3616), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3517, 3616), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((9392, 9424), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9403, 9424), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((12036, 12068), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12047, 12068), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((13646, 13749), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13657, 13749), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((1190, 1201), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1197, 1201), True, 'import numpy as np\n'), ((1255, 1268), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1265, 1268), False, 'import cv2\n'), ((16899, 16917), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16909, 16917), False, 'from PIL import Image\n'), ((18135, 18234), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18147, 18234), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((18237, 18252), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18249, 18252), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2290, 2300), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2294, 2300), False, 'from pathlib import Path\n'), ((6717, 6736), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6728, 6736), False, 'import torch\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self, data: Union[str, Path] = "coco128.yaml", model: str = "yolov8n.pt", uri: str = "~/ultralytics/explorer"
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1680, 1873), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1686, 1873), False, 'from ultralytics.data.augment import Format\n'), ((2137, 2192), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2162, 2192), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2243, 2263), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2258, 2263), False, 'import lancedb\n'), ((2514, 2525), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2518, 2525), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3857, 3885), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3874, 3885), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8492, 8530), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8503, 8530), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((8545, 8562), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8555, 8562), False, 'import duckdb\n'), ((9524, 9544), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9539, 9544), False, 'from PIL import Image\n'), ((12169, 12189), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12184, 12189), False, 'from PIL import Image\n'), ((16441, 16460), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16449, 16460), True, 'import numpy as np\n'), ((16545, 16572), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16552, 16572), True, 'from matplotlib import pyplot as plt\n'), ((16622, 16644), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16632, 16644), True, 'from matplotlib import pyplot as plt\n'), ((16653, 16672), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16663, 16672), True, 'from matplotlib import pyplot as plt\n'), ((16681, 16710), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16690, 16710), True, 'from matplotlib import pyplot as plt\n'), ((16728, 16737), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16735, 16737), False, 'from io import BytesIO\n'), ((16746, 16779), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16757, 16779), True, 'from matplotlib import pyplot as plt\n'), ((3318, 3404), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3329, 3404), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((3506, 3616), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3517, 3616), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((9392, 9424), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9403, 9424), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((12036, 12068), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12047, 12068), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((13646, 13749), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13657, 13749), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((1190, 1201), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1197, 1201), True, 'import numpy as np\n'), ((1255, 1268), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1265, 1268), False, 'import cv2\n'), ((16899, 16917), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16909, 16917), False, 'from PIL import Image\n'), ((18135, 18234), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18147, 18234), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((18237, 18252), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18249, 18252), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2290, 2300), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2294, 2300), False, 'from pathlib import Path\n'), ((6717, 6736), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6728, 6736), False, 'import torch\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self, data: Union[str, Path] = "coco128.yaml", model: str = "yolov8n.pt", uri: str = "~/ultralytics/explorer"
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1680, 1873), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1686, 1873), False, 'from ultralytics.data.augment import Format\n'), ((2137, 2192), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2162, 2192), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2243, 2263), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2258, 2263), False, 'import lancedb\n'), ((2514, 2525), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2518, 2525), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3857, 3885), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3874, 3885), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8492, 8530), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8503, 8530), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((8545, 8562), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8555, 8562), False, 'import duckdb\n'), ((9524, 9544), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9539, 9544), False, 'from PIL import Image\n'), ((12169, 12189), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12184, 12189), False, 'from PIL import Image\n'), ((16441, 16460), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16449, 16460), True, 'import numpy as np\n'), ((16545, 16572), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16552, 16572), True, 'from matplotlib import pyplot as plt\n'), ((16622, 16644), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16632, 16644), True, 'from matplotlib import pyplot as plt\n'), ((16653, 16672), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16663, 16672), True, 'from matplotlib import pyplot as plt\n'), ((16681, 16710), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16690, 16710), True, 'from matplotlib import pyplot as plt\n'), ((16728, 16737), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16735, 16737), False, 'from io import BytesIO\n'), ((16746, 16779), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16757, 16779), True, 'from matplotlib import pyplot as plt\n'), ((3318, 3404), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3329, 3404), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((3506, 3616), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3517, 3616), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((9392, 9424), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9403, 9424), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((12036, 12068), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12047, 12068), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((13646, 13749), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13657, 13749), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((1190, 1201), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1197, 1201), True, 'import numpy as np\n'), ((1255, 1268), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1265, 1268), False, 'import cv2\n'), ((16899, 16917), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16909, 16917), False, 'from PIL import Image\n'), ((18135, 18234), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18147, 18234), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((18237, 18252), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18249, 18252), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2290, 2300), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2294, 2300), False, 'from pathlib import Path\n'), ((6717, 6736), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6728, 6736), False, 'import torch\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self, data: Union[str, Path] = "coco128.yaml", model: str = "yolov8n.pt", uri: str = "~/ultralytics/explorer"
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1680, 1873), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1686, 1873), False, 'from ultralytics.data.augment import Format\n'), ((2137, 2192), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2162, 2192), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2243, 2263), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2258, 2263), False, 'import lancedb\n'), ((2514, 2525), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2518, 2525), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3857, 3885), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3874, 3885), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8492, 8530), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8503, 8530), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((8545, 8562), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8555, 8562), False, 'import duckdb\n'), ((9524, 9544), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9539, 9544), False, 'from PIL import Image\n'), ((12169, 12189), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12184, 12189), False, 'from PIL import Image\n'), ((16441, 16460), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16449, 16460), True, 'import numpy as np\n'), ((16545, 16572), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16552, 16572), True, 'from matplotlib import pyplot as plt\n'), ((16622, 16644), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16632, 16644), True, 'from matplotlib import pyplot as plt\n'), ((16653, 16672), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16663, 16672), True, 'from matplotlib import pyplot as plt\n'), ((16681, 16710), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16690, 16710), True, 'from matplotlib import pyplot as plt\n'), ((16728, 16737), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16735, 16737), False, 'from io import BytesIO\n'), ((16746, 16779), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16757, 16779), True, 'from matplotlib import pyplot as plt\n'), ((3318, 3404), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3329, 3404), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((3506, 3616), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3517, 3616), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((9392, 9424), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9403, 9424), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((12036, 12068), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12047, 12068), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((13646, 13749), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13657, 13749), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((1190, 1201), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1197, 1201), True, 'import numpy as np\n'), ((1255, 1268), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1265, 1268), False, 'import cv2\n'), ((16899, 16917), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16909, 16917), False, 'from PIL import Image\n'), ((18135, 18234), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18147, 18234), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((18237, 18252), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18249, 18252), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2290, 2300), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2294, 2300), False, 'from pathlib import Path\n'), ((6717, 6736), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6728, 6736), False, 'import torch\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.legacy_filters():
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text or "", # ensure text is a string
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2782, 2802), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2797, 2802), False, 'import lancedb\n'), ((1179, 1208), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1185, 1208), True, 'import numpy as np\n'), ((3214, 3293), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=True, flat_metadata=self.flat_metadata)\n', (3235, 3293), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((1089, 1113), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1095, 1113), True, 'import numpy as np\n'), ((5548, 5584), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5563, 5584), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.legacy_filters():
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text or "", # ensure text is a string
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2782, 2802), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2797, 2802), False, 'import lancedb\n'), ((1179, 1208), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1185, 1208), True, 'import numpy as np\n'), ((3214, 3293), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=True, flat_metadata=self.flat_metadata)\n', (3235, 3293), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((1089, 1113), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1095, 1113), True, 'import numpy as np\n'), ((5548, 5584), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5563, 5584), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.legacy_filters():
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text or "", # ensure text is a string
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2782, 2802), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2797, 2802), False, 'import lancedb\n'), ((1179, 1208), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1185, 1208), True, 'import numpy as np\n'), ((3214, 3293), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=True, flat_metadata=self.flat_metadata)\n', (3235, 3293), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((1089, 1113), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1095, 1113), True, 'import numpy as np\n'), ((5548, 5584), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5563, 5584), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.legacy_filters():
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text or "", # ensure text is a string
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2782, 2802), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2797, 2802), False, 'import lancedb\n'), ((1179, 1208), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1185, 1208), True, 'import numpy as np\n'), ((3214, 3293), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=True, flat_metadata=self.flat_metadata)\n', (3235, 3293), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((1089, 1113), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1095, 1113), True, 'import numpy as np\n'), ((5548, 5584), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5563, 5584), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
import lancedb
import numpy as np
import pandas as pd
import pyarrow as pa
def client_vector_db(vector_db_config: dict) -> lancedb.LanceDBConnection:
"""Connect to a lancedb instance"""
return lancedb.connect(**vector_db_config)
def initialize_vector_db_indices(
client_vector_db: lancedb.LanceDBConnection,
class_name: str,
embedding_dimension: int,
) -> bool:
"""Initialize the LanceDB table;
NOTE this pattern currently doesn't work and is due to a bug with lancedb
"""
schema = pa.schema(
[
("squad_id", pa.string()),
("title", pa.string()),
("context", pa.string()),
("embedding_service", pa.string()),
("model_name", pa.string()),
pa.field("vector", type=pa.list_(pa.float32(), list_size=embedding_dimension)),
]
)
client_vector_db.create_table(name=class_name, schema=schema, mode="create")
return True
def reset_vector_db(client_vector_db: lancedb.LanceDBConnection) -> bool:
"""Delete all tables from the database"""
for table_name in client_vector_db.table_names():
client_vector_db.drop_table(table_name)
return True
def data_objects(
ids: list[str],
titles: list[str],
text_contents: list[str],
embeddings: list[np.ndarray],
metadata: dict,
) -> list[dict]:
"""Create valid LanceDB objects"""
assert len(ids) == len(titles) == len(text_contents) == len(embeddings)
return [
dict(squad_id=id_, title=title, context=context, vector=embedding, **metadata)
for id_, title, context, embedding in zip(ids, titles, text_contents, embeddings)
]
def push_to_vector_db(
client_vector_db: lancedb.LanceDBConnection,
class_name: str,
data_objects: list[dict],
embedding_metric: str = "cosine",
) -> int:
"""Push dataframe of objects to LanceDB.
Return number of objects.
"""
df = pd.DataFrame.from_records(data_objects)
table = client_vector_db.create_table(name=class_name, data=df, mode="overwrite")
return table.to_pandas().shape[0]
| [
"lancedb.connect"
] | [((203, 238), 'lancedb.connect', 'lancedb.connect', ([], {}), '(**vector_db_config)\n', (218, 238), False, 'import lancedb\n'), ((1932, 1971), 'pandas.DataFrame.from_records', 'pd.DataFrame.from_records', (['data_objects'], {}), '(data_objects)\n', (1957, 1971), True, 'import pandas as pd\n'), ((568, 579), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (577, 579), True, 'import pyarrow as pa\n'), ((604, 615), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (613, 615), True, 'import pyarrow as pa\n'), ((642, 653), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (651, 653), True, 'import pyarrow as pa\n'), ((690, 701), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (699, 701), True, 'import pyarrow as pa\n'), ((731, 742), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (740, 742), True, 'import pyarrow as pa\n'), ((790, 802), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (800, 802), True, 'import pyarrow as pa\n')] |
from datasets import load_dataset
from panns_inference import AudioTagging
from tqdm import tqdm
from IPython.display import Audio, display
import numpy as np
import lancedb
def create_audio_embedding(audio_data):
return at.inference(audio_data)
def insert_audio():
batches = [batch["audio"] for batch in dataset.iter(100)]
meta_batches = [batch["category"] for batch in dataset.iter(100)]
audio_data = [np.array([audio["array"] for audio in batch]) for batch in batches]
meta_data = [np.array([meta for meta in batch]) for batch in meta_batches]
for i in tqdm(range(len(audio_data))):
(_, embedding) = create_audio_embedding(audio_data[i])
data = [
{
"audio": x[0]["array"],
"vector": x[1],
"sampling_rate": x[0]["sampling_rate"],
"category": x[2],
}
for x in zip(batches[i], embedding, meta_data[i])
]
if table_name not in db.table_names():
tbl = db.create_table(table_name, data)
else:
tbl = db.open_table(table_name)
tbl.add(data)
def search_audio(id):
tbl = db.open_table(table_name)
audio = dataset[id]["audio"]["array"]
category = dataset[id]["category"]
display(Audio(audio, rate=dataset[id]["audio"]["sampling_rate"]))
print("Category:", category)
(_, embedding) = create_audio_embedding(audio[None, :])
result = tbl.search(embedding[0]).limit(5).to_df()
print(result)
for i in range(len(result)):
display(Audio(result["audio"][i], rate=result["sampling_rate"][i]))
print("Category:", result["category"][i])
if __name__ == "__main__":
global dataset, at, db, table_name
dataset = load_dataset("ashraq/esc50", split="train")
at = AudioTagging(checkpoint_path=None, device="cuda")
db = lancedb.connect("data/audio-lancedb")
table_name = "audio-search"
# This function will take a while to run
# Run if you don't have the LanceDB table yet, but skip if you already have it
insert_audio()
# The audio won't display in command line, but it will display in Jupyter Notebook
search_audio(500)
| [
"lancedb.connect"
] | [((1759, 1802), 'datasets.load_dataset', 'load_dataset', (['"""ashraq/esc50"""'], {'split': '"""train"""'}), "('ashraq/esc50', split='train')\n", (1771, 1802), False, 'from datasets import load_dataset\n'), ((1812, 1861), 'panns_inference.AudioTagging', 'AudioTagging', ([], {'checkpoint_path': 'None', 'device': '"""cuda"""'}), "(checkpoint_path=None, device='cuda')\n", (1824, 1861), False, 'from panns_inference import AudioTagging\n'), ((1872, 1909), 'lancedb.connect', 'lancedb.connect', (['"""data/audio-lancedb"""'], {}), "('data/audio-lancedb')\n", (1887, 1909), False, 'import lancedb\n'), ((424, 469), 'numpy.array', 'np.array', (["[audio['array'] for audio in batch]"], {}), "([audio['array'] for audio in batch])\n", (432, 469), True, 'import numpy as np\n'), ((509, 543), 'numpy.array', 'np.array', (['[meta for meta in batch]'], {}), '([meta for meta in batch])\n', (517, 543), True, 'import numpy as np\n'), ((1292, 1348), 'IPython.display.Audio', 'Audio', (['audio'], {'rate': "dataset[id]['audio']['sampling_rate']"}), "(audio, rate=dataset[id]['audio']['sampling_rate'])\n", (1297, 1348), False, 'from IPython.display import Audio, display\n'), ((1566, 1624), 'IPython.display.Audio', 'Audio', (["result['audio'][i]"], {'rate': "result['sampling_rate'][i]"}), "(result['audio'][i], rate=result['sampling_rate'][i])\n", (1571, 1624), False, 'from IPython.display import Audio, display\n')] |
import os
from datetime import datetime
from pathlib import Path
from uuid import uuid4
import lancedb
import pyarrow as pa
import tantivy
from pydantic import computed_field
from slugify import slugify
from sqlalchemy import TIMESTAMP, Engine, text
from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select
from tracecat import auth
from tracecat.auth import decrypt_key, encrypt_key
from tracecat.labels.mitre import get_mitre_tactics_techniques
STORAGE_PATH = Path(os.path.expanduser("~/.tracecat/storage"))
EMBEDDINGS_SIZE = os.environ.get("TRACECAT__EMBEDDINGS_SIZE", 512)
DEFAULT_CASE_ACTIONS = [
"Active compromise",
"Ignore",
"Informational",
"Investigate",
"Quarantined",
"Sinkholed",
]
class User(SQLModel, table=True):
# The id is also the JWT 'sub' claim
id: str | None = Field(default_factory=lambda: uuid4().hex, primary_key=True)
tier: str = "free" # "free" or "premium"
settings: str | None = None # JSON-serialized String of settings
owned_workflows: list["Workflow"] = Relationship(
back_populates="owner",
sa_relationship_kwargs={"cascade": "delete"},
)
case_actions: list["CaseAction"] = Relationship(back_populates="user")
case_contexts: list["CaseContext"] = Relationship(back_populates="user")
secrets: list["Secret"] = Relationship(
back_populates="owner",
sa_relationship_kwargs={"cascade": "delete"},
)
class Resource(SQLModel):
"""Base class for all resources in the system."""
owner_id: str
created_at: datetime = Field(
sa_type=TIMESTAMP(), # UTC Timestamp
sa_column_kwargs={
"server_default": text("CURRENT_TIMESTAMP"),
"nullable": False,
},
)
updated_at: datetime = Field(
sa_type=TIMESTAMP(), # UTC Timestamp
sa_column_kwargs={
"server_default": text("CURRENT_TIMESTAMP"),
"server_onupdate": text("CURRENT_TIMESTAMP"),
"nullable": False,
},
)
class Secret(Resource, table=True):
id: str | None = Field(default_factory=lambda: uuid4().hex, primary_key=True)
name: str | None = Field(default=None, max_length=255, index=True, nullable=True)
encrypted_api_key: bytes | None = Field(default=None, nullable=True)
owner_id: str = Field(foreign_key="user.id")
owner: User | None = Relationship(back_populates="secrets")
@property
def key(self) -> str | None:
if not self.encrypted_api_key:
return None
return decrypt_key(self.encrypted_api_key)
@key.setter
def key(self, value: str) -> None:
self.encrypted_api_key = encrypt_key(value)
class Editor(SQLModel, table=True):
user_id: str | None = Field(default=None, foreign_key="user.id", primary_key=True)
workflow_id: str | None = Field(
default=None, foreign_key="workflow.id", primary_key=True
)
class CaseAction(Resource, table=True):
id: str | None = Field(default_factory=lambda: uuid4().hex, primary_key=True)
tag: str
value: str
user_id: str | None = Field(foreign_key="user.id")
user: User | None = Relationship(back_populates="case_actions")
class CaseContext(Resource, table=True):
id: str | None = Field(default_factory=lambda: uuid4().hex, primary_key=True)
tag: str
value: str
user_id: str | None = Field(foreign_key="user.id")
user: User | None = Relationship(back_populates="case_contexts")
class Workflow(Resource, table=True):
id: str | None = Field(default_factory=lambda: uuid4().hex, primary_key=True)
title: str
description: str
status: str = "offline" # "online" or "offline"
object: str | None = None # JSON-serialized String of react flow object
# Owner
owner_id: str = Field(foreign_key="user.id")
owner: User | None = Relationship(back_populates="owned_workflows")
runs: list["WorkflowRun"] | None = Relationship(back_populates="workflow")
actions: list["Action"] | None = Relationship(
back_populates="workflow",
sa_relationship_kwargs={"cascade": "delete"},
)
webhooks: list["Webhook"] | None = Relationship(
back_populates="workflow",
sa_relationship_kwargs={"cascade": "delete"},
)
@computed_field
@property
def key(self) -> str:
slug = slugify(self.title, separator="_")
return f"{self.id}.{slug}"
class WorkflowRun(Resource, table=True):
id: str | None = Field(default_factory=lambda: uuid4().hex, primary_key=True)
status: str = "pending" # "online" or "offline"
workflow_id: str = Field(foreign_key="workflow.id")
workflow: Workflow | None = Relationship(back_populates="runs")
class Action(Resource, table=True):
id: str | None = Field(default_factory=lambda: uuid4().hex, primary_key=True)
type: str
title: str
description: str
status: str = "offline" # "online" or "offline"
inputs: str | None = None # JSON-serialized String of inputs
workflow_id: str | None = Field(foreign_key="workflow.id")
workflow: Workflow | None = Relationship(back_populates="actions")
@computed_field
@property
def key(self) -> str:
slug = slugify(self.title, separator="_")
return f"{self.id}.{slug}"
class Webhook(Resource, table=True):
"""Webhook is a URL that can be called to trigger a workflow.
Notes
-----
- We need this because we need a way to trigger a workflow from an external source.
- External sources only have access to the path
"""
id: str | None = Field(
default_factory=lambda: uuid4().hex,
primary_key=True,
description="Webhook path",
)
action_id: str | None = Field(foreign_key="action.id")
workflow_id: str | None = Field(foreign_key="workflow.id")
workflow: Workflow | None = Relationship(back_populates="webhooks")
@computed_field
@property
def secret(self) -> str:
return auth.compute_hash(self.id)
def create_db_engine() -> Engine:
STORAGE_PATH.mkdir(parents=True, exist_ok=True)
sqlite_uri = f"sqlite:////{STORAGE_PATH}/database.db"
engine = create_engine(
sqlite_uri, echo=True, connect_args={"check_same_thread": False}
)
return engine
def build_events_index():
index_path = STORAGE_PATH / "event_index"
index_path.mkdir(parents=True, exist_ok=True)
event_schema = (
tantivy.SchemaBuilder()
.add_date_field("published_at", fast=True, stored=True)
.add_text_field("action_id", stored=True)
.add_text_field("action_run_id", stored=True)
.add_text_field("action_title", stored=True)
.add_text_field("action_type", stored=True)
.add_text_field("workflow_id", stored=True)
.add_text_field("workflow_title", stored=True)
.add_text_field("workflow_run_id", stored=True)
.add_json_field("data", stored=True)
.build()
)
tantivy.Index(event_schema, path=str(index_path))
def create_events_index() -> tantivy.Index:
index_path = STORAGE_PATH / "event_index"
return tantivy.Index.open(str(index_path))
def create_vdb_conn() -> lancedb.DBConnection:
db = lancedb.connect(STORAGE_PATH / "vector.db")
return db
CaseSchema = pa.schema(
[
pa.field("id", pa.string(), nullable=False),
pa.field("owner_id", pa.string(), nullable=False),
pa.field("workflow_id", pa.string(), nullable=False),
pa.field("title", pa.string(), nullable=False),
pa.field("payload", pa.string(), nullable=False), # JSON-serialized
pa.field("context", pa.string(), nullable=True), # JSON-serialized
pa.field("malice", pa.string(), nullable=False),
pa.field("status", pa.string(), nullable=False),
pa.field("priority", pa.string(), nullable=False),
pa.field("action", pa.string(), nullable=True),
pa.field("suppression", pa.string(), nullable=True), # JSON-serialized
# pa.field("_action_vector", pa.list_(pa.float32(), list_size=EMBEDDINGS_SIZE)),
# pa.field("_payload_vector", pa.list_(pa.float32(), list_size=EMBEDDINGS_SIZE)),
# pa.field("_context_vector", pa.list_(pa.float32(), list_size=EMBEDDINGS_SIZE)),
]
)
def initialize_db() -> Engine:
# Relational table
engine = create_db_engine()
SQLModel.metadata.create_all(engine)
# VectorDB
db = create_vdb_conn()
db.create_table("cases", schema=CaseSchema, exist_ok=True)
# Search
build_events_index()
# Add TTPs to context table only if context table is empty
with Session(engine) as session:
case_contexts_count = session.exec(select(CaseContext)).all()
if len(case_contexts_count) == 0:
mitre_labels = get_mitre_tactics_techniques()
mitre_contexts = [
CaseContext(owner_id="tracecat", tag="mitre", value=label)
for label in mitre_labels
]
session.add_all(mitre_contexts)
session.commit()
case_actions_count = session.exec(select(CaseAction)).all()
if len(case_actions_count) == 0:
default_actions = [
CaseAction(owner_id="tracecat", tag="case_action", value=case_action)
for case_action in DEFAULT_CASE_ACTIONS
]
session.add_all(default_actions)
session.commit()
return engine
| [
"lancedb.connect"
] | [((557, 605), 'os.environ.get', 'os.environ.get', (['"""TRACECAT__EMBEDDINGS_SIZE"""', '(512)'], {}), "('TRACECAT__EMBEDDINGS_SIZE', 512)\n", (571, 605), False, 'import os\n'), ((496, 537), 'os.path.expanduser', 'os.path.expanduser', (['"""~/.tracecat/storage"""'], {}), "('~/.tracecat/storage')\n", (514, 537), False, 'import os\n'), ((1064, 1150), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""owner"""', 'sa_relationship_kwargs': "{'cascade': 'delete'}"}), "(back_populates='owner', sa_relationship_kwargs={'cascade':\n 'delete'})\n", (1076, 1150), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((1209, 1244), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""user"""'}), "(back_populates='user')\n", (1221, 1244), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((1286, 1321), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""user"""'}), "(back_populates='user')\n", (1298, 1321), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((1352, 1438), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""owner"""', 'sa_relationship_kwargs': "{'cascade': 'delete'}"}), "(back_populates='owner', sa_relationship_kwargs={'cascade':\n 'delete'})\n", (1364, 1438), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((2184, 2246), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'max_length': '(255)', 'index': '(True)', 'nullable': '(True)'}), '(default=None, max_length=255, index=True, nullable=True)\n', (2189, 2246), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((2285, 2319), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'nullable': '(True)'}), '(default=None, nullable=True)\n', (2290, 2319), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((2340, 2368), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""user.id"""'}), "(foreign_key='user.id')\n", (2345, 2368), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((2394, 2432), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""secrets"""'}), "(back_populates='secrets')\n", (2406, 2432), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((2767, 2827), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""user.id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='user.id', primary_key=True)\n", (2772, 2827), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((2858, 2922), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""workflow.id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='workflow.id', primary_key=True)\n", (2863, 2922), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3115, 3143), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""user.id"""'}), "(foreign_key='user.id')\n", (3120, 3143), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3168, 3211), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""case_actions"""'}), "(back_populates='case_actions')\n", (3180, 3211), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3391, 3419), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""user.id"""'}), "(foreign_key='user.id')\n", (3396, 3419), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3444, 3488), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""case_contexts"""'}), "(back_populates='case_contexts')\n", (3456, 3488), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3809, 3837), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""user.id"""'}), "(foreign_key='user.id')\n", (3814, 3837), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3863, 3909), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""owned_workflows"""'}), "(back_populates='owned_workflows')\n", (3875, 3909), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3949, 3988), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""workflow"""'}), "(back_populates='workflow')\n", (3961, 3988), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((4026, 4115), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""workflow"""', 'sa_relationship_kwargs': "{'cascade': 'delete'}"}), "(back_populates='workflow', sa_relationship_kwargs={'cascade':\n 'delete'})\n", (4038, 4115), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((4174, 4263), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""workflow"""', 'sa_relationship_kwargs': "{'cascade': 'delete'}"}), "(back_populates='workflow', sa_relationship_kwargs={'cascade':\n 'delete'})\n", (4186, 4263), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((4630, 4662), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""workflow.id"""'}), "(foreign_key='workflow.id')\n", (4635, 4662), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((4695, 4730), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""runs"""'}), "(back_populates='runs')\n", (4707, 4730), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((5050, 5082), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""workflow.id"""'}), "(foreign_key='workflow.id')\n", (5055, 5082), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((5115, 5153), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""actions"""'}), "(back_populates='actions')\n", (5127, 5153), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((5744, 5774), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""action.id"""'}), "(foreign_key='action.id')\n", (5749, 5774), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((5805, 5837), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""workflow.id"""'}), "(foreign_key='workflow.id')\n", (5810, 5837), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((5870, 5909), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""webhooks"""'}), "(back_populates='webhooks')\n", (5882, 5909), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((6175, 6254), 'sqlmodel.create_engine', 'create_engine', (['sqlite_uri'], {'echo': '(True)', 'connect_args': "{'check_same_thread': False}"}), "(sqlite_uri, echo=True, connect_args={'check_same_thread': False})\n", (6188, 6254), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((7219, 7262), 'lancedb.connect', 'lancedb.connect', (["(STORAGE_PATH / 'vector.db')"], {}), "(STORAGE_PATH / 'vector.db')\n", (7234, 7262), False, 'import lancedb\n'), ((8370, 8406), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (8398, 8406), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((2559, 2594), 'tracecat.auth.decrypt_key', 'decrypt_key', (['self.encrypted_api_key'], {}), '(self.encrypted_api_key)\n', (2570, 2594), False, 'from tracecat.auth import decrypt_key, encrypt_key\n'), ((2684, 2702), 'tracecat.auth.encrypt_key', 'encrypt_key', (['value'], {}), '(value)\n', (2695, 2702), False, 'from tracecat.auth import decrypt_key, encrypt_key\n'), ((4359, 4393), 'slugify.slugify', 'slugify', (['self.title'], {'separator': '"""_"""'}), "(self.title, separator='_')\n", (4366, 4393), False, 'from slugify import slugify\n'), ((5230, 5264), 'slugify.slugify', 'slugify', (['self.title'], {'separator': '"""_"""'}), "(self.title, separator='_')\n", (5237, 5264), False, 'from slugify import slugify\n'), ((5989, 6015), 'tracecat.auth.compute_hash', 'auth.compute_hash', (['self.id'], {}), '(self.id)\n', (6006, 6015), False, 'from tracecat import auth\n'), ((8625, 8640), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (8632, 8640), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((1609, 1620), 'sqlalchemy.TIMESTAMP', 'TIMESTAMP', ([], {}), '()\n', (1618, 1620), False, 'from sqlalchemy import TIMESTAMP, Engine, text\n'), ((1821, 1832), 'sqlalchemy.TIMESTAMP', 'TIMESTAMP', ([], {}), '()\n', (1830, 1832), False, 'from sqlalchemy import TIMESTAMP, Engine, text\n'), ((7332, 7343), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7341, 7343), True, 'import pyarrow as pa\n'), ((7391, 7402), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7400, 7402), True, 'import pyarrow as pa\n'), ((7453, 7464), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7462, 7464), True, 'import pyarrow as pa\n'), ((7509, 7520), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7518, 7520), True, 'import pyarrow as pa\n'), ((7567, 7578), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7576, 7578), True, 'import pyarrow as pa\n'), ((7644, 7655), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7653, 7655), True, 'import pyarrow as pa\n'), ((7719, 7730), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7728, 7730), True, 'import pyarrow as pa\n'), ((7776, 7787), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7785, 7787), True, 'import pyarrow as pa\n'), ((7835, 7846), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7844, 7846), True, 'import pyarrow as pa\n'), ((7892, 7903), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7901, 7903), True, 'import pyarrow as pa\n'), ((7953, 7964), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (7962, 7964), True, 'import pyarrow as pa\n'), ((8792, 8822), 'tracecat.labels.mitre.get_mitre_tactics_techniques', 'get_mitre_tactics_techniques', ([], {}), '()\n', (8820, 8822), False, 'from tracecat.labels.mitre import get_mitre_tactics_techniques\n'), ((1696, 1721), 'sqlalchemy.text', 'text', (['"""CURRENT_TIMESTAMP"""'], {}), "('CURRENT_TIMESTAMP')\n", (1700, 1721), False, 'from sqlalchemy import TIMESTAMP, Engine, text\n'), ((1908, 1933), 'sqlalchemy.text', 'text', (['"""CURRENT_TIMESTAMP"""'], {}), "('CURRENT_TIMESTAMP')\n", (1912, 1933), False, 'from sqlalchemy import TIMESTAMP, Engine, text\n'), ((1966, 1991), 'sqlalchemy.text', 'text', (['"""CURRENT_TIMESTAMP"""'], {}), "('CURRENT_TIMESTAMP')\n", (1970, 1991), False, 'from sqlalchemy import TIMESTAMP, Engine, text\n'), ((877, 884), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (882, 884), False, 'from uuid import uuid4\n'), ((2130, 2137), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (2135, 2137), False, 'from uuid import uuid4\n'), ((3030, 3037), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (3035, 3037), False, 'from uuid import uuid4\n'), ((3306, 3313), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (3311, 3313), False, 'from uuid import uuid4\n'), ((3580, 3587), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (3585, 3587), False, 'from uuid import uuid4\n'), ((4523, 4530), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (4528, 4530), False, 'from uuid import uuid4\n'), ((4820, 4827), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (4825, 4827), False, 'from uuid import uuid4\n'), ((5635, 5642), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (5640, 5642), False, 'from uuid import uuid4\n'), ((8696, 8715), 'sqlmodel.select', 'select', (['CaseContext'], {}), '(CaseContext)\n', (8702, 8715), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((9101, 9119), 'sqlmodel.select', 'select', (['CaseAction'], {}), '(CaseAction)\n', (9107, 9119), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((6440, 6463), 'tantivy.SchemaBuilder', 'tantivy.SchemaBuilder', ([], {}), '()\n', (6461, 6463), False, 'import tantivy\n')] |
from dotenv import load_dotenv
from typing import List
import lancedb
import openai
import os
from gpt_pdf_bot.shared import embed_text
load_dotenv()
class ChatBot:
def __init__(self, table_name: str):
self.db = lancedb.connect(uri=".lancedb")
self.table = self.db[table_name]
def run(self):
while True:
query = input("\nAsk me a question: ")
if query == "exit":
break
print(f"Searching for {query}", end="\n\n")
context = self.retrieve_context(query=query)
print(f"Found {len(context)} results", end="\n\n")
texts = self.retrieve_text_from_context(context=context)
annotations = self.create_annotations_from_context(context=context)
prompt = self.generate_prompt(query=query, context=texts)
response = self.ask_gpt(prompt, annotations=annotations)
print(response, end="\n\n")
def retrieve_context(self, query: str, limit: int = 5) -> List[str]:
emb = embed_text([query])[0]
# TODO: return and pass metadata so we can display the source and page number
context = self.table.search(emb).limit(limit).to_df()
return context
def retrieve_text_from_context(self, context: List[str]) -> List[str]:
"""Extracts only the text from the context, so it can be used in the prompt"""
# curly braces will mess up prompt templating, so remove them
texts = context["text"].str.replace("{", "").str.replace("}", "").tolist()
return texts
def create_annotations_from_context(self, context: List[str]) -> List[str]:
"""Extracts the document metadata from the context,
so it can be displayed with the LLM's response"""
metadata = context["metadata"].tolist()
annotations = []
for meta in metadata:
source = meta["source"]
page_num = meta["page_num"]
annotations.append(f"- file name: {source}, page number: {page_num}")
return annotations
def generate_prompt(self, query: str, context: List[str]) -> str:
# TODO: this is a naive implementation that doesn't handle the case where the context is too long
prepared_context = "\n\n---\n\n".join(context)
prompt_tmpl = f"""Answer the question based on the context below.
{context}
Question: {query}
Answer:"""
return prompt_tmpl.format(query=query, context=prepared_context)
def prepare_messages_for_chat(self, text: str) -> list:
messages = [
{"role": "user", "content": text},
]
return messages
def ask_gpt(self, prompt: str, annotations: List[str]) -> str:
res = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=self.prepare_messages_for_chat(prompt),
temperature=0.7,
api_key=os.environ["OPENAI_API_KEY"],
)
response = res["choices"][0]["message"]["content"].strip()
annotations = "\n".join(annotations).strip()
answer = f"Answer: \n\n{response}\n\n---\n\n"
answer += f"Here are the sources I used:\n{annotations}"
return answer
| [
"lancedb.connect"
] | [((139, 152), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (150, 152), False, 'from dotenv import load_dotenv\n'), ((229, 260), 'lancedb.connect', 'lancedb.connect', ([], {'uri': '""".lancedb"""'}), "(uri='.lancedb')\n", (244, 260), False, 'import lancedb\n'), ((1044, 1063), 'gpt_pdf_bot.shared.embed_text', 'embed_text', (['[query]'], {}), '([query])\n', (1054, 1063), False, 'from gpt_pdf_bot.shared import embed_text\n')] |
import os
from pathlib import Path
import streamlit as st
from langchain.prompts import PromptTemplate
from langchain.schema import StrOutputParser
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.llms import HuggingFaceHub
from langchain_community.vectorstores import LanceDB
from langchain_core.runnables import RunnableParallel, RunnablePassthrough
import lancedb
# HUGGINGFACEHUB_API_TOKEN = st.secrets["HUGGINGFACEHUB_API_TOKEN"]
HUGGINGFACEHUB_API_TOKEN = os.environ["HUGGINGFACEHUB_API_TOKEN"]
@st.cache_resource
def load_chain():
emb_repo = "BAAI/bge-small-en-v1.5"
embeddings = HuggingFaceEmbeddings(model_name=emb_repo)
llm_repo_id = "mistralai/Mixtral-8x7B-Instruct-v0.1"
# llm_repo_id = "NousResearch/Nous-Hermes-2-Mixtral-8x7B-SFT"
llm = HuggingFaceHub(
repo_id=llm_repo_id, model_kwargs={"temperature": 0.1, "max_length": 180}
)
db_path = Path("lancedb")
db = lancedb.connect(db_path)
table = db.open_table("dharma_qa")
docsearch = LanceDB(table, embeddings)
retriever = docsearch.as_retriever(search_kwargs={"k": 4})
# Create system prompt
template = """
You are a respected spiritual teacher, Rob Burbea.
Try to distill the following pieces of context to answer the question at the end.
Question is asked by a student.
If you don't know the answer, just say that you don't know.
Don't try to make up an answer.
Use five sentences maximum and keep the answer as concise as possible.
Avoid answering questions that are not related to the dharma.
If the question is not about the dharma,
politely inform them that you are tuned to only answer
questions about the dharma.
{context}
Question: {question}
Helpful Answer:"""
# Add system prompt to chain
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
prompt = PromptTemplate(template=template, input_variables=["context", "question"])
rag_chain = (
RunnablePassthrough.assign(context=(lambda x: format_docs(x["context"])))
# {"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
rag_chain_with_source = RunnableParallel(
{"context": retriever, "question": RunnablePassthrough()}
).assign(answer=rag_chain)
return rag_chain_with_source, emb_repo, llm_repo_id
| [
"lancedb.connect"
] | [((641, 683), 'langchain_community.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': 'emb_repo'}), '(model_name=emb_repo)\n', (662, 683), False, 'from langchain_community.embeddings import HuggingFaceEmbeddings\n'), ((818, 911), 'langchain_community.llms.HuggingFaceHub', 'HuggingFaceHub', ([], {'repo_id': 'llm_repo_id', 'model_kwargs': "{'temperature': 0.1, 'max_length': 180}"}), "(repo_id=llm_repo_id, model_kwargs={'temperature': 0.1,\n 'max_length': 180})\n", (832, 911), False, 'from langchain_community.llms import HuggingFaceHub\n'), ((936, 951), 'pathlib.Path', 'Path', (['"""lancedb"""'], {}), "('lancedb')\n", (940, 951), False, 'from pathlib import Path\n'), ((961, 985), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (976, 985), False, 'import lancedb\n'), ((1041, 1067), 'langchain_community.vectorstores.LanceDB', 'LanceDB', (['table', 'embeddings'], {}), '(table, embeddings)\n', (1048, 1067), False, 'from langchain_community.vectorstores import LanceDB\n'), ((1931, 2005), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'template', 'input_variables': "['context', 'question']"}), "(template=template, input_variables=['context', 'question'])\n", (1945, 2005), False, 'from langchain.prompts import PromptTemplate\n'), ((2229, 2246), 'langchain.schema.StrOutputParser', 'StrOutputParser', ([], {}), '()\n', (2244, 2246), False, 'from langchain.schema import StrOutputParser\n'), ((2343, 2364), 'langchain_core.runnables.RunnablePassthrough', 'RunnablePassthrough', ([], {}), '()\n', (2362, 2364), False, 'from langchain_core.runnables import RunnableParallel, RunnablePassthrough\n')] |
from flask import Flask, request, jsonify, Response
from flask_cors import CORS
app = Flask(__name__)
CORS(app)
import argparse
import io
import PIL
import duckdb
import lancedb
import lance
import pyarrow.compute as pc
from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast
import gradio as gr
@app.route("/api/python", methods=['POST'])
def get_image_blob():
# Assuming you have the setup_clip_model, get_table, and embed_func functions
data = request.get_json() # Parse incoming JSON data
prompt = data.get('prompt', '') # Get the 'prompt' property from the JSON data
tbl = get_table()
print(data)
emb = embed_func(prompt)
print(emb)
result_df = tbl.search(emb).limit(1).to_df()
if not result_df.empty:
image_col = "image"
image, prompt = _extract(result_df)
# Convert PIL.Image to bytes
image_bytes = io.BytesIO()
image.save(image_bytes, format='PNG')
image_blob = image_bytes.getvalue()
return Response(image_blob, content_type='image/png')
return jsonify({"error": "No matching data found"})
def _extract(df):
image_col = "image"
return PIL.Image.open(io.BytesIO(df.iloc[0][image_col])), df.iloc[0]["prompt"]
MODEL_ID = None
MODEL = None
TOKENIZER = None
PROCESSOR = None
import pyarrow.compute as pc
def get_table():
db = lancedb.connect("data/lancedb")
if "diffusiondb" in db.table_names():
tbl= db.open_table("diffusiondb")
else:
# First data processing and full-text-search index
data = lance.dataset("rawdata.lance").to_table()
# remove null prompts
tbl = db.create_table("diffusiondb", data.filter(~pc.field("prompt").is_null()), mode="overwrite")
tbl = tbl.create_fts_index(["prompt"])
return tbl
def setup_clip_model():
global MODEL_ID, MODEL, TOKENIZER, PROCESSOR
MODEL_ID = "openai/clip-vit-base-patch32"
TOKENIZER = CLIPTokenizerFast.from_pretrained(MODEL_ID)
MODEL = CLIPModel.from_pretrained(MODEL_ID)
PROCESSOR = CLIPProcessor.from_pretrained(MODEL_ID)
def embed_func(query):
inputs = TOKENIZER([query], padding=True, return_tensors="pt")
text_features = MODEL.get_text_features(**inputs)
return text_features.detach().numpy()[0]
setup_clip_model()
| [
"lancedb.connect"
] | [((86, 101), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (91, 101), False, 'from flask import Flask, request, jsonify, Response\n'), ((102, 111), 'flask_cors.CORS', 'CORS', (['app'], {}), '(app)\n', (106, 111), False, 'from flask_cors import CORS\n'), ((468, 486), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (484, 486), False, 'from flask import Flask, request, jsonify, Response\n'), ((1077, 1121), 'flask.jsonify', 'jsonify', (["{'error': 'No matching data found'}"], {}), "({'error': 'No matching data found'})\n", (1084, 1121), False, 'from flask import Flask, request, jsonify, Response\n'), ((1369, 1400), 'lancedb.connect', 'lancedb.connect', (['"""data/lancedb"""'], {}), "('data/lancedb')\n", (1384, 1400), False, 'import lancedb\n'), ((1945, 1988), 'transformers.CLIPTokenizerFast.from_pretrained', 'CLIPTokenizerFast.from_pretrained', (['MODEL_ID'], {}), '(MODEL_ID)\n', (1978, 1988), False, 'from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast\n'), ((2001, 2036), 'transformers.CLIPModel.from_pretrained', 'CLIPModel.from_pretrained', (['MODEL_ID'], {}), '(MODEL_ID)\n', (2026, 2036), False, 'from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast\n'), ((2053, 2092), 'transformers.CLIPProcessor.from_pretrained', 'CLIPProcessor.from_pretrained', (['MODEL_ID'], {}), '(MODEL_ID)\n', (2082, 2092), False, 'from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast\n'), ((899, 911), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (909, 911), False, 'import io\n'), ((1018, 1064), 'flask.Response', 'Response', (['image_blob'], {'content_type': '"""image/png"""'}), "(image_blob, content_type='image/png')\n", (1026, 1064), False, 'from flask import Flask, request, jsonify, Response\n'), ((1191, 1224), 'io.BytesIO', 'io.BytesIO', (['df.iloc[0][image_col]'], {}), '(df.iloc[0][image_col])\n', (1201, 1224), False, 'import io\n'), ((1569, 1599), 'lance.dataset', 'lance.dataset', (['"""rawdata.lance"""'], {}), "('rawdata.lance')\n", (1582, 1599), False, 'import lance\n'), ((1699, 1717), 'pyarrow.compute.field', 'pc.field', (['"""prompt"""'], {}), "('prompt')\n", (1707, 1717), True, 'import pyarrow.compute as pc\n')] |
from PIL import Image
from transformers import CLIPProcessor, CLIPModel
from openai import OpenAI
import lancedb
import os
import pandas as pd
from dotenv import load_dotenv
load_dotenv()
uri = "./sample-lancedb"
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
model_name = "openai/clip-vit-base-patch32"
def create_clip_image_embeddings(image_path, model_name):
# Load the image
image = Image.open(image_path)
# Load the CLIP model and processor
model = CLIPModel.from_pretrained(model_name)
processor = CLIPProcessor.from_pretrained(model_name)
# Generate the image embedding
inputs = processor(images=image, return_tensors="pt")
image_embedding = model.get_image_features(**inputs)
# Return the image embedding
return image_embedding.detach().numpy()[0]
def get_embedding(text, model="text-embedding-3-small"):
text = text.replace("\n", " ")
return client.embeddings.create(input = [text], model=model).data[0].embedding
if __name__ == '__main__':
df = pd.read_csv('listings.csv')
# Create the full description column combining all the text and data columns which will be used to generate the embeddings
df["full_description"] = "Neighbourhood: " +df["Neighborhood"] + \
" Price: " + df["Price"].astype(str) + " Bedrooms: " + df["Bedrooms"].astype(str) + \
" Bathrooms: " + df["Bathrooms"].astype(str) + " House Size: " + df["House Size"].astype(str) + \
"Description: " + df["Description"] + " " + "Neighborhood Description: " + df["Neighborhood Description"]
df['ada_embedding'] = df["full_description"].apply(lambda x: get_embedding(x, model='text-embedding-3-small'))
df['image_embedding'] = df["images"].apply(lambda x: create_clip_image_embeddings(x, model_name))
df.to_csv('listings_with_embeddings.csv', index=False)
db = lancedb.connect(uri)
df_text = df[["Neighborhood","Price","Bedrooms","Bathrooms","images","ada_embedding"]].copy()
df_text = df_text.rename(columns={"ada_embedding":"vector"})
df_images = df[["Neighborhood","Price","Bedrooms","Bathrooms","images","image_embedding"]].copy()
df_images = df_images.rename(columns={"image_embedding":"vector"})
tbl_text = db.create_table("table_from_df_text", data=df_text, exist_ok=True)
print(df_images.head())
print(df_images["vector"][0].shape)
tbl_images = db.create_table("table_from_df_images", data=df_images,exist_ok=True)
| [
"lancedb.connect"
] | [((175, 188), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (186, 188), False, 'from dotenv import load_dotenv\n'), ((403, 425), 'PIL.Image.open', 'Image.open', (['image_path'], {}), '(image_path)\n', (413, 425), False, 'from PIL import Image\n'), ((479, 516), 'transformers.CLIPModel.from_pretrained', 'CLIPModel.from_pretrained', (['model_name'], {}), '(model_name)\n', (504, 516), False, 'from transformers import CLIPProcessor, CLIPModel\n'), ((533, 574), 'transformers.CLIPProcessor.from_pretrained', 'CLIPProcessor.from_pretrained', (['model_name'], {}), '(model_name)\n', (562, 574), False, 'from transformers import CLIPProcessor, CLIPModel\n'), ((1024, 1051), 'pandas.read_csv', 'pd.read_csv', (['"""listings.csv"""'], {}), "('listings.csv')\n", (1035, 1051), True, 'import pandas as pd\n'), ((1851, 1871), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (1866, 1871), False, 'import lancedb\n'), ((238, 265), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (247, 265), False, 'import os\n')] |
import streamlit as st
import pandas as pd
import json
import requests
from pathlib import Path
from datetime import datetime
from jinja2 import Template
import lancedb
import sqlite3
from services.lancedb_notes import IndexDocumentsNotes
from services.auto_research import AutoResearch
st.set_page_config(layout='wide',
page_title='AutoResearch')
notes_folder = Path('data/notes')
collections_folder = Path('data/collections')
tmp_folder = Path('data/tmp')
config_folder = Path('data/config')
with open(config_folder.joinpath('prompt_templates.json'), 'r') as f:
prompt_options = json.load(f)
index_folder = Path('indexes')
sqlite_location = Path('data/indexes/documents.sqlite')
lance_index = lancedb.connect(index_folder)
available_indexes = lance_index.table_names()
index_to_search = st.selectbox(label='Available Indexes', options=available_indexes)
query = st.text_input(label="What do you want to search?", value='')
@st.cache_data
def remote_search(query, collection_name):
results = requests.post('http://localhost:8000/hybrid',
json={'query':query, 'collection_name':collection_name,
'top_k':50, 'fts_weight':0.5, 'vec_weight':1-0.5})
result_data, available_fields = results.json()
available_fields = set(available_fields)
new_fields = set()
for result in result_data:
if 'metadata' in result and len(result['metadata']) > 0:
metadata = json.loads(result['metadata'])
result.update(metadata)
new_fields.update(metadata.keys())
del result['metadata']
return result_data
if 'results_to_save' not in st.session_state:
st.session_state['results_to_save'] = dict()
def add_result_to_save(result):
note_hash = hash(str(result))
st.write(st.session_state['results_to_save'].keys())
if note_hash not in st.session_state['results_to_save']:
st.session_state['results_to_save'][note_hash] = result
else:
del st.session_state['results_to_save'][note_hash]
if query:
st.markdown(f"## {query}")
auto_search = AutoResearch(objective=query, collection_name='trump')
report_results = auto_search.research_question(query)
# st.write(report_results)
for task_idx in range(len(report_results)):
task_description = report_results[str(task_idx + 1)]['task']
task_result = report_results[str(task_idx + 1)]['results']
# st.json(task_result)
st.markdown(f"### Task {task_idx + 1}: {task_description['task']}")
st.markdown(f"**Research Actions**: {task_description['actions']}")
st.markdown(f"**Expected Outcomes**: {task_description['expected_outcomes']}")
st.markdown(f"**Considerations**: {task_description['considerations']}")
st.write()
st.markdown(f"### Full Summary:\n{task_result['final_summary']}")
st.markdown(f"### Summarized Summary:\n{task_result['summarized_summary']}")
st.divider()
for query_idx, sub_query in enumerate(task_result['internet_queries']):
with st.expander(f"Expand for sub query: {sub_query}"):
st.markdown(f"### Subquery: {sub_query}")
# st.json(task_result['queries'])
query_results = task_result['queries'][query_idx]
st.markdown("#### Summary")
st.markdown(query_results['sub_summary'])
st.divider()
for _article in query_results['article_objects']:
st.markdown(f"**Title: {_article['title']}** --- **UUID: {_article['uuid']}**")
st.markdown("**Text**")
_text = _article['text'].replace('\n','\n\n')
st.markdown(f"{_text}")
st.divider()
#
# for index, result in enumerate(query_results):
# # st.write(result)
# st.markdown(f"**:blue[{result['title']}]**")
# st.markdown(f"*:blue[Score: {round(result['score'], 3)}]*")
# with st.container():
# st.write(f"{' '.join(result['text'].split(' ')[:100])}.....")
# with st.expander('See Full Text and Details'):
# full_text, quick_annotate = st.columns([4,1])
# with full_text:
# st.markdown('**Text:**')
# st.markdown(result['text'])
# save_to_collection = st.toggle('Save to collection',key=f'toggle_{index}',
# on_change=add_result_to_save, args=(result, ))
st.divider()
| [
"lancedb.connect"
] | [((288, 348), 'streamlit.set_page_config', 'st.set_page_config', ([], {'layout': '"""wide"""', 'page_title': '"""AutoResearch"""'}), "(layout='wide', page_title='AutoResearch')\n", (306, 348), True, 'import streamlit as st\n'), ((384, 402), 'pathlib.Path', 'Path', (['"""data/notes"""'], {}), "('data/notes')\n", (388, 402), False, 'from pathlib import Path\n'), ((424, 448), 'pathlib.Path', 'Path', (['"""data/collections"""'], {}), "('data/collections')\n", (428, 448), False, 'from pathlib import Path\n'), ((462, 478), 'pathlib.Path', 'Path', (['"""data/tmp"""'], {}), "('data/tmp')\n", (466, 478), False, 'from pathlib import Path\n'), ((495, 514), 'pathlib.Path', 'Path', (['"""data/config"""'], {}), "('data/config')\n", (499, 514), False, 'from pathlib import Path\n'), ((636, 651), 'pathlib.Path', 'Path', (['"""indexes"""'], {}), "('indexes')\n", (640, 651), False, 'from pathlib import Path\n'), ((670, 707), 'pathlib.Path', 'Path', (['"""data/indexes/documents.sqlite"""'], {}), "('data/indexes/documents.sqlite')\n", (674, 707), False, 'from pathlib import Path\n'), ((723, 752), 'lancedb.connect', 'lancedb.connect', (['index_folder'], {}), '(index_folder)\n', (738, 752), False, 'import lancedb\n'), ((817, 883), 'streamlit.selectbox', 'st.selectbox', ([], {'label': '"""Available Indexes"""', 'options': 'available_indexes'}), "(label='Available Indexes', options=available_indexes)\n", (829, 883), True, 'import streamlit as st\n'), ((893, 953), 'streamlit.text_input', 'st.text_input', ([], {'label': '"""What do you want to search?"""', 'value': '""""""'}), "(label='What do you want to search?', value='')\n", (906, 953), True, 'import streamlit as st\n'), ((606, 618), 'json.load', 'json.load', (['f'], {}), '(f)\n', (615, 618), False, 'import json\n'), ((1028, 1195), 'requests.post', 'requests.post', (['"""http://localhost:8000/hybrid"""'], {'json': "{'query': query, 'collection_name': collection_name, 'top_k': 50,\n 'fts_weight': 0.5, 'vec_weight': 1 - 0.5}"}), "('http://localhost:8000/hybrid', json={'query': query,\n 'collection_name': collection_name, 'top_k': 50, 'fts_weight': 0.5,\n 'vec_weight': 1 - 0.5})\n", (1041, 1195), False, 'import requests\n'), ((2085, 2111), 'streamlit.markdown', 'st.markdown', (['f"""## {query}"""'], {}), "(f'## {query}')\n", (2096, 2111), True, 'import streamlit as st\n'), ((2131, 2185), 'services.auto_research.AutoResearch', 'AutoResearch', ([], {'objective': 'query', 'collection_name': '"""trump"""'}), "(objective=query, collection_name='trump')\n", (2143, 2185), False, 'from services.auto_research import AutoResearch\n'), ((2499, 2566), 'streamlit.markdown', 'st.markdown', (['f"""### Task {task_idx + 1}: {task_description[\'task\']}"""'], {}), '(f"### Task {task_idx + 1}: {task_description[\'task\']}")\n', (2510, 2566), True, 'import streamlit as st\n'), ((2575, 2642), 'streamlit.markdown', 'st.markdown', (['f"""**Research Actions**: {task_description[\'actions\']}"""'], {}), '(f"**Research Actions**: {task_description[\'actions\']}")\n', (2586, 2642), True, 'import streamlit as st\n'), ((2651, 2729), 'streamlit.markdown', 'st.markdown', (['f"""**Expected Outcomes**: {task_description[\'expected_outcomes\']}"""'], {}), '(f"**Expected Outcomes**: {task_description[\'expected_outcomes\']}")\n', (2662, 2729), True, 'import streamlit as st\n'), ((2738, 2810), 'streamlit.markdown', 'st.markdown', (['f"""**Considerations**: {task_description[\'considerations\']}"""'], {}), '(f"**Considerations**: {task_description[\'considerations\']}")\n', (2749, 2810), True, 'import streamlit as st\n'), ((2819, 2829), 'streamlit.write', 'st.write', ([], {}), '()\n', (2827, 2829), True, 'import streamlit as st\n'), ((2838, 2906), 'streamlit.markdown', 'st.markdown', (['f"""### Full Summary:\n{task_result[\'final_summary\']}"""'], {}), '(f"""### Full Summary:\n{task_result[\'final_summary\']}""")\n', (2849, 2906), True, 'import streamlit as st\n'), ((2912, 2991), 'streamlit.markdown', 'st.markdown', (['f"""### Summarized Summary:\n{task_result[\'summarized_summary\']}"""'], {}), '(f"""### Summarized Summary:\n{task_result[\'summarized_summary\']}""")\n', (2923, 2991), True, 'import streamlit as st\n'), ((2997, 3009), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (3007, 3009), True, 'import streamlit as st\n'), ((1482, 1512), 'json.loads', 'json.loads', (["result['metadata']"], {}), "(result['metadata'])\n", (1492, 1512), False, 'import json\n'), ((4586, 4598), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (4596, 4598), True, 'import streamlit as st\n'), ((3107, 3156), 'streamlit.expander', 'st.expander', (['f"""Expand for sub query: {sub_query}"""'], {}), "(f'Expand for sub query: {sub_query}')\n", (3118, 3156), True, 'import streamlit as st\n'), ((3174, 3215), 'streamlit.markdown', 'st.markdown', (['f"""### Subquery: {sub_query}"""'], {}), "(f'### Subquery: {sub_query}')\n", (3185, 3215), True, 'import streamlit as st\n'), ((3348, 3375), 'streamlit.markdown', 'st.markdown', (['"""#### Summary"""'], {}), "('#### Summary')\n", (3359, 3375), True, 'import streamlit as st\n'), ((3392, 3433), 'streamlit.markdown', 'st.markdown', (["query_results['sub_summary']"], {}), "(query_results['sub_summary'])\n", (3403, 3433), True, 'import streamlit as st\n'), ((3450, 3462), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (3460, 3462), True, 'import streamlit as st\n'), ((3549, 3634), 'streamlit.markdown', 'st.markdown', (['f"""**Title: {_article[\'title\']}** --- **UUID: {_article[\'uuid\']}**"""'], {}), '(f"**Title: {_article[\'title\']}** --- **UUID: {_article[\'uuid\']}**"\n )\n', (3560, 3634), True, 'import streamlit as st\n'), ((3650, 3673), 'streamlit.markdown', 'st.markdown', (['"""**Text**"""'], {}), "('**Text**')\n", (3661, 3673), True, 'import streamlit as st\n'), ((3760, 3783), 'streamlit.markdown', 'st.markdown', (['f"""{_text}"""'], {}), "(f'{_text}')\n", (3771, 3783), True, 'import streamlit as st\n'), ((3804, 3816), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (3814, 3816), True, 'import streamlit as st\n')] |
#!/usr/bin/env python
import numpy as np
import time
import lancedb
import pyarrow as pa
import logging
import sys
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
def generate_random_data_vectors(num_vectors, dimension, offset=0):
"""
Generate random data vectors.
:param num_vectors: Number of vectors to generate.
:param dimension: Dimension of each vector.
:param offset: Offset for ID numbering.
:return: List of dictionaries with vector and id.
"""
return [{"vector": list(np.random.random(dimension)), "id": i} for i in range(1 + offset, num_vectors + 1 + offset)]
def generate_random_vectors(num_vectors, dimension):
"""
Generate random vectors using NumPy.
:param num_vectors: Number of vectors to generate.
:param dimension: Dimension of each vector.
:return: NumPy array of random vectors.
"""
return np.random.random((num_vectors, dimension))
def main():
# Parameters
dimension = 1536
num_vectors = 100000
num_query_vectors = 20000
top_k = 10
db = lancedb.connect("./vectors.db")
logging.info("Starting Generating Data")
db_vectors = generate_random_data_vectors(num_vectors, dimension)
query_vectors = generate_random_vectors(num_query_vectors, dimension)
logging.info("Finished Generating Data")
logging.info("Starting to insert data")
table = db.create_table("vectors", data=db_vectors)
for i in range(1, 10):
logging.info(f"Starting to insert data with offset {i}")
table.add(generate_random_data_vectors(num_vectors, dimension, offset=num_vectors * i))
logging.info(f"Finished inserting data with offset {i}")
logging.info("Finished inserting data")
logging.info("Starting Queries")
query_times = []
for i, query_vector in enumerate(query_vectors):
start_time = time.time()
table.search(query_vector).limit(top_k) # Adjust based on actual search method
end_time = time.time()
query_duration_ms = (end_time - start_time) * 1000
query_times.append(query_duration_ms)
if (i + 1) % 5000 == 0:
logging.info(f"Iteration {i + 1}")
percentiles = [50, 90, 95, 99]
percentile_results = {p: np.percentile(query_times, p) for p in percentiles}
logging.info("Query Time Percentiles (milliseconds):")
for percentile, value in percentile_results.items():
logging.info(f"{percentile}th percentile: {value:.3f} ms")
db.drop_table("vectors")
if __name__ == "__main__":
main()
| [
"lancedb.connect"
] | [((117, 213), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""%(asctime)s - %(levelname)s - %(message)s"""'}), "(level=logging.INFO, format=\n '%(asctime)s - %(levelname)s - %(message)s')\n", (136, 213), False, 'import logging\n'), ((922, 964), 'numpy.random.random', 'np.random.random', (['(num_vectors, dimension)'], {}), '((num_vectors, dimension))\n', (938, 964), True, 'import numpy as np\n'), ((1097, 1128), 'lancedb.connect', 'lancedb.connect', (['"""./vectors.db"""'], {}), "('./vectors.db')\n", (1112, 1128), False, 'import lancedb\n'), ((1134, 1174), 'logging.info', 'logging.info', (['"""Starting Generating Data"""'], {}), "('Starting Generating Data')\n", (1146, 1174), False, 'import logging\n'), ((1323, 1363), 'logging.info', 'logging.info', (['"""Finished Generating Data"""'], {}), "('Finished Generating Data')\n", (1335, 1363), False, 'import logging\n'), ((1369, 1408), 'logging.info', 'logging.info', (['"""Starting to insert data"""'], {}), "('Starting to insert data')\n", (1381, 1408), False, 'import logging\n'), ((1723, 1762), 'logging.info', 'logging.info', (['"""Finished inserting data"""'], {}), "('Finished inserting data')\n", (1735, 1762), False, 'import logging\n'), ((1768, 1800), 'logging.info', 'logging.info', (['"""Starting Queries"""'], {}), "('Starting Queries')\n", (1780, 1800), False, 'import logging\n'), ((2334, 2388), 'logging.info', 'logging.info', (['"""Query Time Percentiles (milliseconds):"""'], {}), "('Query Time Percentiles (milliseconds):')\n", (2346, 2388), False, 'import logging\n'), ((1500, 1556), 'logging.info', 'logging.info', (['f"""Starting to insert data with offset {i}"""'], {}), "(f'Starting to insert data with offset {i}')\n", (1512, 1556), False, 'import logging\n'), ((1661, 1717), 'logging.info', 'logging.info', (['f"""Finished inserting data with offset {i}"""'], {}), "(f'Finished inserting data with offset {i}')\n", (1673, 1717), False, 'import logging\n'), ((1896, 1907), 'time.time', 'time.time', ([], {}), '()\n', (1905, 1907), False, 'import time\n'), ((2015, 2026), 'time.time', 'time.time', ([], {}), '()\n', (2024, 2026), False, 'import time\n'), ((2277, 2306), 'numpy.percentile', 'np.percentile', (['query_times', 'p'], {}), '(query_times, p)\n', (2290, 2306), True, 'import numpy as np\n'), ((2454, 2512), 'logging.info', 'logging.info', (['f"""{percentile}th percentile: {value:.3f} ms"""'], {}), "(f'{percentile}th percentile: {value:.3f} ms')\n", (2466, 2512), False, 'import logging\n'), ((2177, 2211), 'logging.info', 'logging.info', (['f"""Iteration {i + 1}"""'], {}), "(f'Iteration {i + 1}')\n", (2189, 2211), False, 'import logging\n'), ((558, 585), 'numpy.random.random', 'np.random.random', (['dimension'], {}), '(dimension)\n', (574, 585), True, 'import numpy as np\n')] |
import argparse
import lancedb
import torch
import pyarrow as pa
import pandas as pd
from pathlib import Path
import tqdm
import numpy as np
import logging
from transformers import AutoConfig
from sentence_transformers import SentenceTransformer
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--emb-model", help="embedding model name on HF hub", type=str)
parser.add_argument("--table", help="table name in DB", type=str)
parser.add_argument("--input-dir", help="input directory with documents to ingest", type=str)
parser.add_argument("--vec-column", help="vector column name in the table", type=str, default="vector")
parser.add_argument("--text-column", help="text column name in the table", type=str, default="text")
parser.add_argument("--db-loc", help="database location", type=str,
default=str(Path().resolve() / ".lancedb"))
parser.add_argument("--batch-size", help="batch size for embedding model", type=int, default=32)
parser.add_argument("--num-partitions", help="number of partitions for index", type=int, default=256)
parser.add_argument("--num-sub-vectors", help="number of sub-vectors for index", type=int, default=96)
args = parser.parse_args()
emb_config = AutoConfig.from_pretrained(args.emb_model)
emb_dimension = emb_config.hidden_size
assert emb_dimension % args.num_sub_vectors == 0, \
"Embedding size must be divisible by the num of sub vectors"
model = SentenceTransformer(args.emb_model)
model.eval()
if torch.backends.mps.is_available():
device = "mps"
elif torch.cuda.is_available():
device = "cuda"
else:
device = "cpu"
logger.info(f"using {str(device)} device")
db = lancedb.connect(args.db_loc)
schema = pa.schema(
[
pa.field(args.vec_column, pa.list_(pa.float32(), emb_dimension)),
pa.field(args.text_column, pa.string())
]
)
tbl = db.create_table(args.table, schema=schema, mode="overwrite")
input_dir = Path(args.input_dir)
files = list(input_dir.rglob("*"))
sentences = []
for file in files:
if file.is_file():
with open(file, encoding='utf-8') as f:
sentences.append(f.read())
for i in tqdm.tqdm(range(0, int(np.ceil(len(sentences) / args.batch_size)))):
try:
batch = [sent for sent in sentences[i * args.batch_size:(i + 1) * args.batch_size] if len(sent) > 0]
encoded = model.encode(batch, normalize_embeddings=True, device=device)
encoded = [list(vec) for vec in encoded]
df = pd.DataFrame({
args.vec_column: encoded,
args.text_column: batch
})
tbl.add(df)
except:
logger.info(f"batch {i} was skipped")
'''
create ivf-pd index https://lancedb.github.io/lancedb/ann_indexes/
with the size of the transformer docs, index is not really needed
but we'll do it for demonstrational purposes
'''
tbl.create_index(
num_partitions=args.num_partitions,
num_sub_vectors=args.num_sub_vectors,
vector_column_name=args.vec_column
)
if __name__ == "__main__":
main() | [
"lancedb.connect"
] | [((248, 287), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (267, 287), False, 'import logging\n'), ((297, 324), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (314, 324), False, 'import logging\n'), ((352, 377), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (375, 377), False, 'import argparse\n'), ((1351, 1393), 'transformers.AutoConfig.from_pretrained', 'AutoConfig.from_pretrained', (['args.emb_model'], {}), '(args.emb_model)\n', (1377, 1393), False, 'from transformers import AutoConfig\n'), ((1576, 1611), 'sentence_transformers.SentenceTransformer', 'SentenceTransformer', (['args.emb_model'], {}), '(args.emb_model)\n', (1595, 1611), False, 'from sentence_transformers import SentenceTransformer\n'), ((1637, 1670), 'torch.backends.mps.is_available', 'torch.backends.mps.is_available', ([], {}), '()\n', (1668, 1670), False, 'import torch\n'), ((1845, 1873), 'lancedb.connect', 'lancedb.connect', (['args.db_loc'], {}), '(args.db_loc)\n', (1860, 1873), False, 'import lancedb\n'), ((2135, 2155), 'pathlib.Path', 'Path', (['args.input_dir'], {}), '(args.input_dir)\n', (2139, 2155), False, 'from pathlib import Path\n'), ((1704, 1729), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (1727, 1729), False, 'import torch\n'), ((2724, 2789), 'pandas.DataFrame', 'pd.DataFrame', (['{args.vec_column: encoded, args.text_column: batch}'], {}), '({args.vec_column: encoded, args.text_column: batch})\n', (2736, 2789), True, 'import pandas as pd\n'), ((2020, 2031), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (2029, 2031), True, 'import pyarrow as pa\n'), ((1952, 1964), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (1962, 1964), True, 'import pyarrow as pa\n'), ((955, 961), 'pathlib.Path', 'Path', ([], {}), '()\n', (959, 961), False, 'from pathlib import Path\n')] |
# import ray
# from ray import serve
# from ray.serve.handle import DeploymentHandle
import logging
from collections import Counter, defaultdict, deque
import pickle
import os
import glob
import cv2
import numpy as np
import pandas as pd
import torch
from PIL import Image
import lancedb
import clip
from detic import Detic
from detic.inference import load_classifier
from xmem import XMem
from detectron2.structures import Boxes, Instances, pairwise_iou
from torchvision.ops import masks_to_boxes
from torchvision import transforms
from ..util.nms import asymmetric_nms, mask_iou
from ..util.vocab import prepare_vocab
from .download import ensure_db
from IPython import embed
log = logging.getLogger(__name__)
# ray.init()
IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406)
IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225)
class CustomTrack(XMem.Track):
hoi_class_id = 0
state_class_label = ''
confidence = 0
def __init__(self, track_id, t_obs, n_init=3, state_history_len=4, hand_obj_history_len=4, **kw):
super().__init__(track_id, t_obs, n_init, **kw)
self.label_count = Counter()
self.obj_state_history = deque(maxlen=state_history_len)
self.hoi_history = deque(maxlen=hand_obj_history_len)
self.obj_state_dist = pd.Series(dtype=float)
self.obj_state_dist_label = None
self.z_clips = {}
@property
def pred_label(self):
xs = self.label_count.most_common(1)
return xs[0][0] if xs else None
def update_state(self, state, pred_label, alpha=0.1):
# if the label changed, delete the state
if self.obj_state_dist_label != pred_label:
self.obj_state_dist = pd.Series(dtype=float)
self.obj_state_dist_label = pred_label
# set default
for k in state.index:
if k not in self.obj_state_dist:
self.obj_state_dist[k] = state[k]
# do EMA
for k in self.obj_state_dist.index:
self.obj_state_dist[k] = (1 - alpha) * self.obj_state_dist[k] + alpha * state.get(k, 0)
return self.obj_state_dist
import itertools
def cat_instances(instance_lists):
assert all(isinstance(i, Instances) for i in instance_lists)
assert len(instance_lists) > 0
if len(instance_lists) == 1:
return instance_lists[0]
image_size = instance_lists[0].image_size
if not isinstance(image_size, torch.Tensor): # could be a tensor in tracing
for i in instance_lists[1:]:
assert i.image_size == image_size
ret = Instances(image_size)
for k in instance_lists[0]._fields.keys():
values = [i.get(k) for i in instance_lists]
v0 = values[0]
if isinstance(v0, torch.Tensor):
values = torch.cat(values, dim=0)
elif isinstance(v0, list):
values = list(itertools.chain(*values))
elif hasattr(type(v0), "cat"):
values = type(v0).cat(values)
elif isinstance(v0, np.ndarray):
values = np.concatenate(values, axis=0)
else:
raise ValueError("Unsupported type {} for concatenation".format(type(v0)))
ret.set(k, values)
return ret
# IGNORE_CLASSES = ['table', 'dining_table', 'table-tennis_table', 'person']
class ObjectDetector:
def __init__(
self,
vocabulary,
state_db_fname=None,
custom_state_clsf_fname=None,
xmem_config={},
conf_threshold=0.3,
detect_hoi=None,
state_key='state',
detic_config_key=None,
additional_roi_heads=None,
filter_tracked_detections_from_frame=True,
device='cuda', detic_device=None, egohos_device=None, xmem_device=None, clip_device=None
):
# initialize models
self.device = device
self.detic_device = detic_device or device
self.egohos_device = egohos_device or device
self.xmem_device = xmem_device or device
self.clip_device = clip_device or device
self.detic = Detic([], config=detic_config_key, masks=True, one_class_per_proposal=3, conf_threshold=conf_threshold, device=self.detic_device).eval().to(self.detic_device)
self.conf_threshold = conf_threshold
self.filter_tracked_detections_from_frame = filter_tracked_detections_from_frame
self.egohos = None
self.egohos_type = np.array(['', 'hand', 'hand', 'obj', 'obj', 'obj', 'obj', 'obj', 'obj', 'cb'])
self.egohos_hand_side = np.array(['', 'left', 'right', 'left', 'right', 'both', 'left', 'right', 'both', ''])
if detect_hoi is not False:
try:
from egohos import EgoHos
self.egohos = EgoHos('obj1', device=self.egohos_device).eval()
except ImportError as e:
print('Could not import EgoHOS:', e)
if detect_hoi is True:
raise
self.xmem = XMem({
'top_k': 30,
'mem_every': 30,
'deep_update_every': -1,
'enable_long_term': True,
'enable_long_term_count_usage': True,
'num_prototypes': 128,
'min_mid_term_frames': 6,
'max_mid_term_frames': 12,
'max_long_term_elements': 1000,
'tentative_frames': 3,
'tentative_age': 3,
'max_age': 60, # in steps
# 'min_iou': 0.3,
**xmem_config,
}, Track=CustomTrack).to(self.xmem_device).eval()
# load vocabularies
if vocabulary.get('base'):
_, open_meta, _ = load_classifier(vocabulary['base'], prepare=False)
base_prompts = open_meta.thing_classes
else:
base_prompts = []
tracked_prompts, tracked_vocab = prepare_vocab(vocabulary['tracked'])
untracked_prompts, untracked_vocab = prepare_vocab(vocabulary.get('untracked') or [])
# get base prompts
remove_vocab = set(vocabulary.get('remove') or ()) | set(tracked_prompts) | set(untracked_prompts)
base_prompts = [c for c in base_prompts if c not in remove_vocab]
# get base vocab
equival_map = vocabulary.get('equivalencies') or {}
base_vocab = [equival_map.get(c, c) for c in base_prompts]
# combine and get final vocab list
full_vocab = list(tracked_vocab) + list(untracked_vocab) + base_vocab
full_prompts = list(tracked_prompts) + list(untracked_prompts) + base_prompts
# if external_vocab:
# full_vocab, full_prompts = list(zip(*[(v, p) for v, p in zip(full_vocab, full_prompts) if v not in external_vocab])) or [[],[]]
if additional_roi_heads is not None and not isinstance(additional_roi_heads, list):
additional_roi_heads = [additional_roi_heads]
self.additional_roi_heads = [
(torch.load(h) if isinstance(h, str) else h).to(self.detic_device)
for h in additional_roi_heads or []
]
for h in self.additional_roi_heads:
h.one_class_per_proposal = self.detic.predictor.model.roi_heads.one_class_per_proposal
# for p in h.box_predictor:
# p.test_topk_per_image = self.detic.predictor.model.roi_heads.box_predictor[0].test_topk_per_image
self.additional_roi_heads_labels = [h.labels for h in self.additional_roi_heads]
labels_covered_by_roi_heads = [l for ls in self.additional_roi_heads_labels for l in ls]
self.base_labels = [l for l in full_vocab if l not in labels_covered_by_roi_heads]
self.tracked_vocabulary = np.asarray(list(set(tracked_vocab)))
self.ignored_vocabulary = np.asarray(['IGNORE'])
self.skill_clsf, _, _ = load_classifier(full_prompts, metadata_name='lvis+', device=self.detic_device)
self.skill_labels = np.asarray(full_vocab)
self.skill_labels_is_tracked = np.isin(self.skill_labels, self.tracked_vocabulary)
self.state_ema = 0.25
self.state_clsf_type = None
self.state_db_key = state_key
self.obj_label_names = []
self.sklearn_state_clsfs = {}
if state_db_fname:
if state_db_fname.endswith(".lancedb"):
self.state_clsf_type = 'lancedb'
# image encoder
self.clip, self.clip_pre = clip.load("ViT-B/32", device=self.clip_device)
state_db_fname = ensure_db(state_db_fname)
print("Using state db:", state_db_fname)
self.obj_state_db = lancedb.connect(state_db_fname)
self.obj_label_names = self.obj_state_db.table_names()
self.obj_state_tables = {
k: self.obj_state_db[k]
for k in self.obj_label_names
}
print(f"State DB: {self.obj_state_db}")
print(f'Objects: {self.obj_label_names}')
# for name in self.obj_label_names:
# tbl.create_index(num_partitions=256, num_sub_vectors=96)
if custom_state_clsf_fname:
import joblib
for f in glob.glob(os.path.join(custom_state_clsf_fname, '*.joblib')):
cname = os.path.splitext(os.path.basename(f))[0]
print('using sklearn model:', cname, f)
c = joblib.load(f)
c.labels = np.array([l.strip() for l in open(os.path.join(custom_state_clsf_fname, f'{cname}.txt')).readlines() if l.strip()])
self.sklearn_state_clsfs[cname] = c
print(c)
# print(self.sklearn_state_clsfs)
# input()
# embed()
# if state_db_fname.endswith('.pkl'):
# self.state_clsf_type = 'dino'
# self.dinov2 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_reg').eval().to(self.clip_device)
# self.dino_head, self.dino_classes = pickle.load(open(state_db_fname, 'rb'))
# dino_object_classes = np.array([x.split('__')[0] for x in self.dino_classes])
# self.dino_state_classes = np.array([x.split('__')[1] for x in self.dino_classes])
# self.obj_label_names = np.unique(dino_object_classes)
# self.dino_label_mask = {l: dino_object_classes == l for l in self.obj_label_names}
# self.dino_pre = transforms.Compose([
# transforms.Resize(224, interpolation=transforms.InterpolationMode.BICUBIC),
# transforms.CenterCrop(224),
# transforms.ToTensor(),
# transforms.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD),
# ])
# print(f'Objects: {self.obj_label_names}')
def clear_memory(self):
self.xmem.clear_memory()
def predict_objects(self, image):
# ----------------------------- Object Detection ----------------------------- #
# predict objects
detic_query = self.detic.build_query(image)
outputs = detic_query.detect(self.skill_clsf, conf_threshold=0.3, labels=self.skill_labels)
instances = outputs['instances']
if self.additional_roi_heads:
instances = instances[np.isin(instances.pred_labels, self.base_labels)]
instances_list = [
detic_query.detect(self.skill_clsf, roi_heads=h, labels=self.skill_labels)['instances']
for h in self.additional_roi_heads
]
instances_list = [
h[np.isin(h.pred_labels, ls)]
for h, ls in zip(instances_list, self.additional_roi_heads_labels)
]
instances = self._cat_instances(instances, instances_list)
instances = self._filter_detections(instances)
return instances, detic_query
def _cat_instances(self, instances, instances_list):
if instances_list:
instances = [instances] + instances_list
# score_len = max(x.topk_scores.shape[1] for x in instances)
# print(score_len)
# class_offset = 0
# for x in instances:
# try:
# x.remove('topk_scores')
# x.remove('topk_classes')
# x.remove('topk_labels')
# except KeyError:
# pass
# s = x.pred_scores
# x.pred_scores = torch.cat([torch.zeros((len(s), class_offset), device=s.device, dtype=s.dtype), s], dim=1)
# class_offset += s.shape[1]
# s = x.topk_scores
# if s.shape[1] < score_len:
# print(s.shape)
# x2 = torch.zeros((len(x), score_len), device=s.device, dtype=s.dtype)
# x2[:, :len(s)] = s
# x.topk_scores = x2
instances = cat_instances(instances)
return instances
def _filter_detections(self, instances):
# drop any ignored instances
instances = instances[~np.isin(instances.pred_labels, self.ignored_vocabulary)]
# filter out objects completely inside another object
obj_priority = torch.from_numpy(np.isin(instances.pred_labels, self.tracked_vocabulary)).int()
filtered, overlap = asymmetric_nms(instances.pred_boxes.tensor, instances.scores, obj_priority, iou_threshold=0.85)
filtered_instances = instances[filtered.cpu().numpy()]
# if Counter(instances.pred_labels.tolist()).get('tortilla', 0) > 1:
# embed()
for i, i_ov in enumerate(overlap):
if not len(i_ov): continue
# get overlapping instances
overlap_insts = instances[i_ov.cpu().numpy()]
log.info(f"object {filtered_instances.pred_labels[i]} filtered {overlap_insts.pred_labels}")
# merge overlapping detections with the same label
overlap_insts = overlap_insts[overlap_insts.pred_labels == filtered_instances.pred_labels[i]]
if len(overlap_insts):
log.info(f"object {filtered_instances.pred_labels[i]} merged {len(overlap_insts)}")
filtered_instances.pred_masks[i] |= torch.maximum(
filtered_instances.pred_masks[i],
overlap_insts.pred_masks.max(0).values)
# filtered_instances.pred_masks
# log.info("filtered detections %s", len(filtered_instances))
return filtered_instances
def predict_hoi(self, image):
if self.egohos is None:
return None, None
# -------------------------- Hand-Object Interaction ------------------------- #
# predict HOI
hoi_masks, hoi_class_ids = self.egohos(image)
keep = hoi_masks.sum(1).sum(1) > 4
hoi_masks = hoi_masks[keep]
hoi_class_ids = hoi_class_ids[keep.cpu().numpy()]
# create detectron2 instances
instances = Instances(
image.shape,
pred_masks=hoi_masks,
pred_boxes=Boxes(masks_to_boxes(hoi_masks)),
pred_hoi_classes=hoi_class_ids)
# get a mask of the hands
hand_mask = hoi_masks[self.egohos_type[hoi_class_ids] == 'hand'].sum(0)
return instances, hand_mask
def merge_hoi(self, other_detections, hoi_detections, detic_query):
if hoi_detections is None:
return None
is_obj_type = self.egohos_type[hoi_detections.pred_hoi_classes] == 'obj'
hoi_obj_detections = hoi_detections[is_obj_type]
hoi_obj_masks = hoi_obj_detections.pred_masks
hoi_obj_boxes = hoi_obj_detections.pred_boxes.tensor
hoi_obj_hand_side = self.egohos_hand_side[hoi_detections.pred_hoi_classes[is_obj_type]]
# ----------------- Compare & Merge HOI with Object Detector ----------------- #
# get mask iou
other_detections = [d for d in other_detections if d is not None]
mask_list = [d.pred_masks.to(self.egohos_device) for d in other_detections]
det_masks = torch.cat(mask_list) if mask_list else torch.zeros(0, hoi_obj_masks.shape[1:])
iou = mask_iou(det_masks, hoi_obj_masks)
# add hand side interaction to tracks
i = 0
for d, b in zip(other_detections, mask_list):
d.left_hand_interaction = iou[i:i+len(b), hoi_obj_hand_side == 'left'].sum(1)
d.right_hand_interaction = iou[i:i+len(b), hoi_obj_hand_side == 'right'].sum(1)
d.both_hand_interaction = iou[i:i+len(b), hoi_obj_hand_side == 'both'].sum(1)
i += len(b)
# ---------------------- Predict class for unlabeled HOI --------------------- #
# get hoi objects with poor overlap
hoi_iou = iou.sum(0)
hoi_is_its_own_obj = hoi_iou < 0.2
bbox = hoi_obj_boxes[hoi_is_its_own_obj].to(self.detic_device)
masks = hoi_obj_masks[hoi_is_its_own_obj]
scores = torch.Tensor(1 - hoi_iou[hoi_is_its_own_obj])
labels = np.array(['unknown' for i in range(len(bbox))])
try:
instances = Instances(
hoi_obj_detections.image_size,
scores=scores,
pred_boxes=Boxes(bbox),
pred_masks=masks,
pred_labels=labels,
)
except AssertionError:
print('failed creating unknown instances:\n', bbox.shape, masks.shape, scores.shape, labels.shape, '\n')
instances = None
return instances
# # get labels for HOIs
# hoi_outputs = detic_query.predict(
# hoi_obj_boxes[hoi_is_its_own_obj].to(self.detic_device),
# self.skill_clsf, labels=self.skill_labels)
# hoi_detections2 = hoi_outputs['instances']
# hoi_detections2.pred_labels[:] = 'unknown'
# pm = hoi_obj_detections.pred_masks[hoi_is_its_own_obj]
# # if len(hoi_detections2) != len(pm):
# # print(len(hoi_detections2))
# # print(hoi_is_its_own_obj)
# # print(pm.shape)
# hoi_detections2.pred_masks = pm
# hoi_is_its_own_obj = hoi_is_its_own_obj.cpu()
# hoi_detections2.left_hand_interaction = torch.as_tensor(hoi_obj_hand_side == 'left')[hoi_is_its_own_obj]
# hoi_detections2.right_hand_interaction = torch.as_tensor(hoi_obj_hand_side == 'right')[hoi_is_its_own_obj]
# hoi_detections2.both_hand_interaction = torch.as_tensor(hoi_obj_hand_side == 'both')[hoi_is_its_own_obj]
# # TODO: add top K classes and scores
# return hoi_detections2
def filter_objects(self, detections):
return detections, detections
def track_objects(self, image, detections, negative_mask=None):
#
det_mask = None
det_scores = None
if detections is not None:
# other_mask = frame_detections.pred_masks
det_scores = detections.pred_scores
det_mask = detections.pred_masks.to(self.xmem_device)
if negative_mask is not None:
negative_mask = negative_mask.to(self.xmem_device)
# run xmem
pred_mask, track_ids, input_track_ids = self.xmem(
image, det_mask,
negative_mask=negative_mask,
mask_scores=det_scores,
tracked_labels=self.skill_labels_is_tracked,
only_confirmed=True
)
# update label counts
tracks = self.xmem.tracks
if input_track_ids is not None and detections is not None:
labels = detections.pred_labels
scores = detections.scores
for i, ti in enumerate(input_track_ids):
if ti >= 0:
tracks[ti].label_count.update([labels[i]])
tracks[ti].confidence = scores[i]
instances = Instances(
image.shape,
scores=torch.Tensor([tracks[i].confidence for i in track_ids]),
pred_boxes=Boxes(masks_to_boxes(pred_mask)),
pred_masks=pred_mask,
pred_labels=np.array([tracks[i].pred_label for i in track_ids]),
track_ids=torch.as_tensor(track_ids),
)
frame_detections = detections
if detections is not None and self.filter_tracked_detections_from_frame:
frame_detections = detections[~np.isin(detections.pred_labels, self.tracked_vocabulary)]
return instances, frame_detections
def predict_state(self, image, detections, det_shape=None):
states = []
labels = detections.pred_labels
has_state = np.isin(labels, self.obj_label_names)
track_ids = detections.track_ids.cpu().numpy() if detections.has('track_ids') else None
dets = detections[has_state]
i_z = {k: i for i, k in enumerate(np.where(has_state)[0])}
Z_imgs = self._encode_boxes(image, dets.pred_boxes.tensor, det_shape=det_shape) if len(dets) else None
for i in range(len(detections)):
pred_label = labels[i]
state = {}
if has_state[i]:
if pred_label in self.sklearn_state_clsfs:
z = Z_imgs[i_z[i]].cpu().numpy()
c = self.sklearn_state_clsfs[pred_label]
y = c.predict_proba(z[None])[0]
state = {
c: x for c, x in zip(c.labels.tolist(), y.tolist())
}
# print(pred_label)
# print(sorted(state.items(), key=lambda x: x[1])[-3:])
# input()
elif self.state_clsf_type == 'lancedb':
z = Z_imgs[i_z[i]].cpu().numpy()
df = self.obj_state_tables[pred_label].search(z).limit(11).to_df()
state = df[self.state_db_key].value_counts()
state = state / state.sum()
if track_ids is not None and track_ids[i] in self.xmem.tracks:
state = self.xmem.tracks[track_ids[i]].update_state(state, pred_label, self.state_ema)
state = state.to_dict()
# elif self.state_clsf_type == 'dino':
# y = Z_imgs[i_z[i]]#.cpu().numpy()
# assert y.shape[-1] == self.dino_state_classes.shape[0]
# label_mask = self.dino_label_mask[pred_label]
# state = dict(zip(
# self.dino_state_classes[label_mask].tolist(),
# y[label_mask].tolist()
# ))
# # print(state)
states.append(state)
# detections.__dict__['pred_states'] = states
detections.pred_states = np.array(states)
return detections
def _encode_boxes(self, img, boxes, det_shape=None):
# BGR
# encode each bounding box crop with clip
# print(f"Clip encoding: {img.shape} {boxes.shape}")
# for x, y, x2, y2 in boxes.cpu():
# Image.fromarray(img[
# int(y):max(int(np.ceil(y2)), int(y+2)),
# int(x):max(int(np.ceil(x2)), int(x+2)),
# ::-1]).save("box.png")
# input()
sx = sy = 1
if det_shape:
hd, wd = det_shape[:2]
hi, wi = img.shape[:2]
sx = wi / wd
sy = hi / hd
crops = [
Image.fromarray(img[
max(int(y * sy - 15), 0):max(int(np.ceil(y2 * sy + 15)), int(y * sy + 2)),
max(int(x * sx - 15), 0):max(int(np.ceil(x2 * sx + 15)), int(x * sx + 2)),
::-1])
for x, y, x2, y2 in boxes.cpu()
]
# for c in crops:
# c.save('demo.png')
# input()
if self.state_clsf_type == 'lancedb':
Z = self.clip.encode_image(torch.stack([self.clip_pre(x) for x in crops]).to(self.clip_device))
# Z /= Z.norm(dim=1, keepdim=True)
# elif self.state_clsf_type == 'dino':
# Z = self.dinov2(torch.stack([self.dino_pre(x) for x in crops]).to(self.clip_device))
# Z = self.dino_head.predict_proba(np.ascontiguousarray(Z.cpu().numpy()))
return Z
def classify(self, Z, labels):
outputs = []
for z, l in zip(Z, labels):
z_cls, txt_cls = self.classifiers[l]
out = (z @ z_cls.t()).softmax(dim=-1).cpu().numpy()
i = np.argmax(out)
outputs.append(txt_cls[i])
return np.atleast_1d(np.array(outputs))
def forward(self, img, boxes, labels):
valid = self.can_classify(labels)
if not valid.any():
return np.array([None]*len(boxes))
labels = np.asanyarray(labels)
Z = self.encode_boxes(img, boxes[valid])
clses = self.classify(Z, labels[valid])
all_clses = np.array([None]*len(boxes))
all_clses[valid] = clses
return all_clses
class Perception:
def __init__(self, *a, detect_every_n_seconds=0.5, max_width=480, **kw):
self.detector = ObjectDetector(*a, **kw)
self.detect_every_n_seconds = 0 if detect_every_n_seconds is True else detect_every_n_seconds
self.detection_timestamp = -1e30
self.max_width = max_width
def clear_memory(self):
self.detector.clear_memory()
self.detection_timestamp = -1e30
@torch.no_grad()
def predict(self, image, timestamp):
# # Get a small version of the image
# h, w = image.shape[:2]
full_image = image
# W = self.max_width
# H = int((h * W / w)//16)*16
# # W = int((w * H / h)//16)*16
# image = cv2.resize(image, (W, H))
# ---------------------------------------------------------------------------- #
# Detection: every N frames #
# ---------------------------------------------------------------------------- #
detections = detic_query = hoi_detections = hand_mask = None
is_detection_frame = abs(timestamp - self.detection_timestamp) >= self.detect_every_n_seconds
if is_detection_frame:
self.detection_timestamp = timestamp
# -------------------------- First we detect objects ------------------------- #
# Detic:
detections, detic_query = self.detector.predict_objects(image)
# ------------------ Then we detect hand object interactions ----------------- #
# EgoHOS:
hoi_detections, hand_mask = self.detector.predict_hoi(image)
# ---------------------------------------------------------------------------- #
# Tracking: Every frame #
# ---------------------------------------------------------------------------- #
# ------------------------- Then we track the objects ------------------------ #
# XMem:
track_detections, frame_detections = self.detector.track_objects(image, detections, negative_mask=hand_mask)
# ---------------------------------------------------------------------------- #
# Predicting Object State #
# ---------------------------------------------------------------------------- #
# -------- For objects with labels we care about, classify their state ------- #
# LanceDB:
# predict state for tracked objects
track_detections = self.detector.predict_state(full_image, track_detections, image.shape)
# predict state for untracked objects
# if frame_detections is not None:
# frame_detections = self.detector.predict_state(image, frame_detections)
# ----- Merge our multi-model detections into a single set of detections ----- #
# IoU between tracks+frames & hoi:
if hoi_detections is not None:
# Merging HOI into track_detections, frame_detections, hoi_detections
hoi_detections = self.detector.merge_hoi(
[track_detections, frame_detections],
hoi_detections,
detic_query)
self.timestamp = timestamp
return track_detections, frame_detections, hoi_detections
def serialize_detections(self, detections, frame_shape, include_mask=False):
if detections is None:
return None
bboxes = detections.pred_boxes.tensor.cpu().numpy()
bboxes[:, 0] /= frame_shape[1]
bboxes[:, 1] /= frame_shape[0]
bboxes[:, 2] /= frame_shape[1]
bboxes[:, 3] /= frame_shape[0]
labels = detections.pred_labels
track_ids = detections.track_ids.cpu().numpy() if detections.has('track_ids') else None
scores = detections.scores.cpu().numpy() if detections.has('scores') else None
hand_object = { k: f'{k}_hand_interaction' for k in ['left', 'right', 'both'] }
hand_object = {
k: detections.get(kk).cpu().numpy()
for k, kk in hand_object.items()
if detections.has(kk)}
possible_labels = None
if detections.has('topk_scores'):
possible_labels = [
{k: v for k, v in zip(ls.tolist(), ss.tolist()) if v > 0}
for ls, ss in zip(detections.topk_labels, detections.topk_scores.cpu().numpy())
]
segments = None
if include_mask and detections.has('pred_masks'):
segments = [
norm_contours(cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[0], frame_shape)
for mask in detections.pred_masks.cpu().numpy().astype(np.uint8)
]
states = detections.pred_states if detections.has('pred_states') else None
output = []
for i in range(len(detections)):
data = {
'xyxyn': bboxes[i].tolist(),
'label': labels[i],
}
if scores is not None:
data['confidence'] = scores[i]
if hand_object:
data['hand_object'] = ho = {k: x[i] for k, x in hand_object.items()}
data['hand_object_interaction'] = max(ho.values(), default=0)
if possible_labels:
data['possible_labels'] = possible_labels[i]
if segments:
data['segment'] = segments[i]
if states is not None:
data['state'] = states[i]
if track_ids is not None:
data['segment_track_id'] = track_ids[i]
output.append(data)
return output
def norm_contours(contours, shape):
contours = list(contours)
WH = np.array(shape[:2][::-1])
for i in range(len(contours)):
contours[i] = np.asarray(contours[i]) / WH
return contours
| [
"lancedb.connect"
] | [((690, 717), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (707, 717), False, 'import logging\n'), ((2546, 2567), 'detectron2.structures.Instances', 'Instances', (['image_size'], {}), '(image_size)\n', (2555, 2567), False, 'from detectron2.structures import Boxes, Instances, pairwise_iou\n'), ((25276, 25291), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (25289, 25291), False, 'import torch\n'), ((30636, 30661), 'numpy.array', 'np.array', (['shape[:2][::-1]'], {}), '(shape[:2][::-1])\n', (30644, 30661), True, 'import numpy as np\n'), ((1109, 1118), 'collections.Counter', 'Counter', ([], {}), '()\n', (1116, 1118), False, 'from collections import Counter, defaultdict, deque\n'), ((1152, 1183), 'collections.deque', 'deque', ([], {'maxlen': 'state_history_len'}), '(maxlen=state_history_len)\n', (1157, 1183), False, 'from collections import Counter, defaultdict, deque\n'), ((1211, 1245), 'collections.deque', 'deque', ([], {'maxlen': 'hand_obj_history_len'}), '(maxlen=hand_obj_history_len)\n', (1216, 1245), False, 'from collections import Counter, defaultdict, deque\n'), ((1276, 1298), 'pandas.Series', 'pd.Series', ([], {'dtype': 'float'}), '(dtype=float)\n', (1285, 1298), True, 'import pandas as pd\n'), ((4361, 4439), 'numpy.array', 'np.array', (["['', 'hand', 'hand', 'obj', 'obj', 'obj', 'obj', 'obj', 'obj', 'cb']"], {}), "(['', 'hand', 'hand', 'obj', 'obj', 'obj', 'obj', 'obj', 'obj', 'cb'])\n", (4369, 4439), True, 'import numpy as np\n'), ((4472, 4561), 'numpy.array', 'np.array', (["['', 'left', 'right', 'left', 'right', 'both', 'left', 'right', 'both', '']"], {}), "(['', 'left', 'right', 'left', 'right', 'both', 'left', 'right',\n 'both', ''])\n", (4480, 4561), True, 'import numpy as np\n'), ((7642, 7664), 'numpy.asarray', 'np.asarray', (["['IGNORE']"], {}), "(['IGNORE'])\n", (7652, 7664), True, 'import numpy as np\n'), ((7698, 7776), 'detic.inference.load_classifier', 'load_classifier', (['full_prompts'], {'metadata_name': '"""lvis+"""', 'device': 'self.detic_device'}), "(full_prompts, metadata_name='lvis+', device=self.detic_device)\n", (7713, 7776), False, 'from detic.inference import load_classifier\n'), ((7805, 7827), 'numpy.asarray', 'np.asarray', (['full_vocab'], {}), '(full_vocab)\n', (7815, 7827), True, 'import numpy as np\n'), ((7867, 7918), 'numpy.isin', 'np.isin', (['self.skill_labels', 'self.tracked_vocabulary'], {}), '(self.skill_labels, self.tracked_vocabulary)\n', (7874, 7918), True, 'import numpy as np\n'), ((16878, 16923), 'torch.Tensor', 'torch.Tensor', (['(1 - hoi_iou[hoi_is_its_own_obj])'], {}), '(1 - hoi_iou[hoi_is_its_own_obj])\n', (16890, 16923), False, 'import torch\n'), ((20496, 20533), 'numpy.isin', 'np.isin', (['labels', 'self.obj_label_names'], {}), '(labels, self.obj_label_names)\n', (20503, 20533), True, 'import numpy as np\n'), ((22621, 22637), 'numpy.array', 'np.array', (['states'], {}), '(states)\n', (22629, 22637), True, 'import numpy as np\n'), ((24614, 24635), 'numpy.asanyarray', 'np.asanyarray', (['labels'], {}), '(labels)\n', (24627, 24635), True, 'import numpy as np\n'), ((1686, 1708), 'pandas.Series', 'pd.Series', ([], {'dtype': 'float'}), '(dtype=float)\n', (1695, 1708), True, 'import pandas as pd\n'), ((2752, 2776), 'torch.cat', 'torch.cat', (['values'], {'dim': '(0)'}), '(values, dim=0)\n', (2761, 2776), False, 'import torch\n'), ((5565, 5615), 'detic.inference.load_classifier', 'load_classifier', (["vocabulary['base']"], {'prepare': '(False)'}), "(vocabulary['base'], prepare=False)\n", (5580, 5615), False, 'from detic.inference import load_classifier\n'), ((15994, 16014), 'torch.cat', 'torch.cat', (['mask_list'], {}), '(mask_list)\n', (16003, 16014), False, 'import torch\n'), ((16033, 16072), 'torch.zeros', 'torch.zeros', (['(0)', 'hoi_obj_masks.shape[1:]'], {}), '(0, hoi_obj_masks.shape[1:])\n', (16044, 16072), False, 'import torch\n'), ((24334, 24348), 'numpy.argmax', 'np.argmax', (['out'], {}), '(out)\n', (24343, 24348), True, 'import numpy as np\n'), ((24417, 24434), 'numpy.array', 'np.array', (['outputs'], {}), '(outputs)\n', (24425, 24434), True, 'import numpy as np\n'), ((30719, 30742), 'numpy.asarray', 'np.asarray', (['contours[i]'], {}), '(contours[i])\n', (30729, 30742), True, 'import numpy as np\n'), ((8300, 8346), 'clip.load', 'clip.load', (['"""ViT-B/32"""'], {'device': 'self.clip_device'}), "('ViT-B/32', device=self.clip_device)\n", (8309, 8346), False, 'import clip\n'), ((8500, 8531), 'lancedb.connect', 'lancedb.connect', (['state_db_fname'], {}), '(state_db_fname)\n', (8515, 8531), False, 'import lancedb\n'), ((9096, 9145), 'os.path.join', 'os.path.join', (['custom_state_clsf_fname', '"""*.joblib"""'], {}), "(custom_state_clsf_fname, '*.joblib')\n", (9108, 9145), False, 'import os\n'), ((9289, 9303), 'joblib.load', 'joblib.load', (['f'], {}), '(f)\n', (9300, 9303), False, 'import joblib\n'), ((11199, 11247), 'numpy.isin', 'np.isin', (['instances.pred_labels', 'self.base_labels'], {}), '(instances.pred_labels, self.base_labels)\n', (11206, 11247), True, 'import numpy as np\n'), ((13013, 13068), 'numpy.isin', 'np.isin', (['instances.pred_labels', 'self.ignored_vocabulary'], {}), '(instances.pred_labels, self.ignored_vocabulary)\n', (13020, 13068), True, 'import numpy as np\n'), ((19801, 19856), 'torch.Tensor', 'torch.Tensor', (['[tracks[i].confidence for i in track_ids]'], {}), '([tracks[i].confidence for i in track_ids])\n', (19813, 19856), False, 'import torch\n'), ((19973, 20024), 'numpy.array', 'np.array', (['[tracks[i].pred_label for i in track_ids]'], {}), '([tracks[i].pred_label for i in track_ids])\n', (19981, 20024), True, 'import numpy as np\n'), ((20048, 20074), 'torch.as_tensor', 'torch.as_tensor', (['track_ids'], {}), '(track_ids)\n', (20063, 20074), False, 'import torch\n'), ((2838, 2862), 'itertools.chain', 'itertools.chain', (['*values'], {}), '(*values)\n', (2853, 2862), False, 'import itertools\n'), ((11498, 11524), 'numpy.isin', 'np.isin', (['h.pred_labels', 'ls'], {}), '(h.pred_labels, ls)\n', (11505, 11524), True, 'import numpy as np\n'), ((13172, 13227), 'numpy.isin', 'np.isin', (['instances.pred_labels', 'self.tracked_vocabulary'], {}), '(instances.pred_labels, self.tracked_vocabulary)\n', (13179, 13227), True, 'import numpy as np\n'), ((14998, 15023), 'torchvision.ops.masks_to_boxes', 'masks_to_boxes', (['hoi_masks'], {}), '(hoi_masks)\n', (15012, 15023), False, 'from torchvision.ops import masks_to_boxes\n'), ((17142, 17153), 'detectron2.structures.Boxes', 'Boxes', (['bbox'], {}), '(bbox)\n', (17147, 17153), False, 'from detectron2.structures import Boxes, Instances, pairwise_iou\n'), ((19887, 19912), 'torchvision.ops.masks_to_boxes', 'masks_to_boxes', (['pred_mask'], {}), '(pred_mask)\n', (19901, 19912), False, 'from torchvision.ops import masks_to_boxes\n'), ((20249, 20305), 'numpy.isin', 'np.isin', (['detections.pred_labels', 'self.tracked_vocabulary'], {}), '(detections.pred_labels, self.tracked_vocabulary)\n', (20256, 20305), True, 'import numpy as np\n'), ((3007, 3037), 'numpy.concatenate', 'np.concatenate', (['values'], {'axis': '(0)'}), '(values, axis=0)\n', (3021, 3037), True, 'import numpy as np\n'), ((4012, 4145), 'detic.Detic', 'Detic', (['[]'], {'config': 'detic_config_key', 'masks': '(True)', 'one_class_per_proposal': '(3)', 'conf_threshold': 'conf_threshold', 'device': 'self.detic_device'}), '([], config=detic_config_key, masks=True, one_class_per_proposal=3,\n conf_threshold=conf_threshold, device=self.detic_device)\n', (4017, 4145), False, 'from detic import Detic\n'), ((4683, 4724), 'egohos.EgoHos', 'EgoHos', (['"""obj1"""'], {'device': 'self.egohos_device'}), "('obj1', device=self.egohos_device)\n", (4689, 4724), False, 'from egohos import EgoHos\n'), ((4908, 5249), 'xmem.XMem', 'XMem', (["{'top_k': 30, 'mem_every': 30, 'deep_update_every': -1, 'enable_long_term':\n True, 'enable_long_term_count_usage': True, 'num_prototypes': 128,\n 'min_mid_term_frames': 6, 'max_mid_term_frames': 12,\n 'max_long_term_elements': 1000, 'tentative_frames': 3, 'tentative_age':\n 3, 'max_age': 60, **xmem_config}"], {'Track': 'CustomTrack'}), "({'top_k': 30, 'mem_every': 30, 'deep_update_every': -1,\n 'enable_long_term': True, 'enable_long_term_count_usage': True,\n 'num_prototypes': 128, 'min_mid_term_frames': 6, 'max_mid_term_frames':\n 12, 'max_long_term_elements': 1000, 'tentative_frames': 3,\n 'tentative_age': 3, 'max_age': 60, **xmem_config}, Track=CustomTrack)\n", (4912, 5249), False, 'from xmem import XMem\n'), ((6835, 6848), 'torch.load', 'torch.load', (['h'], {}), '(h)\n', (6845, 6848), False, 'import torch\n'), ((9189, 9208), 'os.path.basename', 'os.path.basename', (['f'], {}), '(f)\n', (9205, 9208), False, 'import os\n'), ((20709, 20728), 'numpy.where', 'np.where', (['has_state'], {}), '(has_state)\n', (20717, 20728), True, 'import numpy as np\n'), ((29453, 29515), 'cv2.findContours', 'cv2.findContours', (['mask', 'cv2.RETR_TREE', 'cv2.CHAIN_APPROX_SIMPLE'], {}), '(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n', (29469, 29515), False, 'import cv2\n'), ((23366, 23387), 'numpy.ceil', 'np.ceil', (['(y2 * sy + 15)'], {}), '(y2 * sy + 15)\n', (23373, 23387), True, 'import numpy as np\n'), ((23457, 23478), 'numpy.ceil', 'np.ceil', (['(x2 * sx + 15)'], {}), '(x2 * sx + 15)\n', (23464, 23478), True, 'import numpy as np\n'), ((9365, 9418), 'os.path.join', 'os.path.join', (['custom_state_clsf_fname', 'f"""{cname}.txt"""'], {}), "(custom_state_clsf_fname, f'{cname}.txt')\n", (9377, 9418), False, 'import os\n')] |
import os, sqlite3, lancedb, tiktoken, bcrypt
from pinecone import Pinecone, ServerlessSpec
from enum import Enum
from langchain_community.vectorstores import LanceDB, Chroma
from langchain_community.vectorstores import Pinecone as LangPinecone
import streamlit as st
def SetHeader(page_title: str):
st.set_page_config(page_title=page_title, page_icon="https://indico.bnl.gov/event/19560/logo-410523303.png", layout="wide")
st.warning("This project is being continuously developed. Please write to [email protected] for any feedback.")
col_l, col1, col2, col_r = st.columns([1, 3, 3, 1])
with col1:
st.image("https://indico.bnl.gov/event/19560/logo-410523303.png")
with col2:
st.title("""AI4EIC - RAG QA-ChatBot""", anchor = "AI4EIC-RAG-QA-Bot", help = "Will Link to arxiv proceeding here.")
class UserNotFoundError(Exception):
pass
class DBNotFoundError(Exception):
pass
def hash_password(password: str):
bytes = password.encode('utf-8')
salt = bcrypt.gensalt()
return bcrypt.hashpw(bytes, salt)
def get_user_info(db_name, username):
if not os.path.exists(db_name):
raise FileNotFoundError(f"Database {db_name} does not exist.")
conn = sqlite3.connect(db_name)
cursor = conn.cursor()
cursor.execute('''
SELECT username, first_name, last_name, password FROM users WHERE username = ?
''', (username,))
user = cursor.fetchone()
conn.close()
if user:
return user
else:
return None
def SetOpenAIModel(model_name: str):
if model_name == "4":
return False
class VectorDB(Enum):
LANCE = 1
CHROMA = 2
PINECONE = 3
def GetRetriever(TYPE: str, vector_config: dict, search_config = {}):
if TYPE == VectorDB.LANCE.name:
db = lancedb.connect(vector_config["db_name"])
table = db.open_table(vector_config["table_name"])
return LanceDB(connection = table,
embedding = vector_config["embedding_function"]
).as_retriever(search_type = search_config.get("metric", "similarity"),
search_kwargs=search_config.get("search_kwargs", {"k" : 100})
)
elif TYPE == VectorDB.CHROMA.name:
return Chroma(persist_directory = vector_config["db_name"],
embedding_function = vector_config["embedding_function"],
collection_name=vector_config["collection_name"]
).as_retriever(search_type = search_config.get("metric", "similarity"),
search_kwargs=search_config.get("search_kwargs", {"k" : 100})
)
elif TYPE == VectorDB.PINECONE.name:
pc = Pinecone(api_key = vector_config["db_api_key"])
if vector_config["index_name"] not in pc.list_indexes().names():
raise DBNotFoundError(f"Database {vector_config['index_name']} does not exist.")
return LangPinecone.from_existing_index(vector_config["index_name"],
vector_config["embedding_function"]
).as_retriever(search_type = search_config.get("metric", "similarity"),
search_kwargs=search_config.get("search_kwargs", {"k" : 100})
)
else:
raise NotImplementedError("Invalid VectorDB type")
def num_tokens_from_prompt(prompt: str, model: str) -> int:
"""Return the number of tokens used by a prompt."""
encoding = tiktoken.encoding_for_model(model)
return len(encoding.encode(prompt))
def num_tokens_from_messages(messages, model) -> int:
"""Return the number of tokens used by a list of messages."""
encoding = tiktoken.encoding_for_model(model)
tokens_per_message = 4 # every message follows <|start|>{role/name}\n{content}<|end|>\n
tokens_per_name = 1
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
for key, value in message.items():
num_tokens += len(encoding.encode(value))
if key == "name":
num_tokens += tokens_per_name
num_tokens += 4 # every reply is primed with <|start|>assistant<|message|>
return num_tokens | [
"lancedb.connect"
] | [((305, 433), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': 'page_title', 'page_icon': '"""https://indico.bnl.gov/event/19560/logo-410523303.png"""', 'layout': '"""wide"""'}), "(page_title=page_title, page_icon=\n 'https://indico.bnl.gov/event/19560/logo-410523303.png', layout='wide')\n", (323, 433), True, 'import streamlit as st\n'), ((433, 553), 'streamlit.warning', 'st.warning', (['"""This project is being continuously developed. Please write to [email protected] for any feedback."""'], {}), "(\n 'This project is being continuously developed. Please write to [email protected] for any feedback.'\n )\n", (443, 553), True, 'import streamlit as st\n'), ((575, 599), 'streamlit.columns', 'st.columns', (['[1, 3, 3, 1]'], {}), '([1, 3, 3, 1])\n', (585, 599), True, 'import streamlit as st\n'), ((1000, 1016), 'bcrypt.gensalt', 'bcrypt.gensalt', ([], {}), '()\n', (1014, 1016), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((1028, 1054), 'bcrypt.hashpw', 'bcrypt.hashpw', (['bytes', 'salt'], {}), '(bytes, salt)\n', (1041, 1054), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((1211, 1235), 'sqlite3.connect', 'sqlite3.connect', (['db_name'], {}), '(db_name)\n', (1226, 1235), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((3705, 3739), 'tiktoken.encoding_for_model', 'tiktoken.encoding_for_model', (['model'], {}), '(model)\n', (3732, 3739), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((3927, 3961), 'tiktoken.encoding_for_model', 'tiktoken.encoding_for_model', (['model'], {}), '(model)\n', (3954, 3961), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((623, 688), 'streamlit.image', 'st.image', (['"""https://indico.bnl.gov/event/19560/logo-410523303.png"""'], {}), "('https://indico.bnl.gov/event/19560/logo-410523303.png')\n", (631, 688), True, 'import streamlit as st\n'), ((712, 824), 'streamlit.title', 'st.title', (['"""AI4EIC - RAG QA-ChatBot"""'], {'anchor': '"""AI4EIC-RAG-QA-Bot"""', 'help': '"""Will Link to arxiv proceeding here."""'}), "('AI4EIC - RAG QA-ChatBot', anchor='AI4EIC-RAG-QA-Bot', help=\n 'Will Link to arxiv proceeding here.')\n", (720, 824), True, 'import streamlit as st\n'), ((1104, 1127), 'os.path.exists', 'os.path.exists', (['db_name'], {}), '(db_name)\n', (1118, 1127), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((1793, 1834), 'lancedb.connect', 'lancedb.connect', (["vector_config['db_name']"], {}), "(vector_config['db_name'])\n", (1808, 1834), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((1909, 1981), 'langchain_community.vectorstores.LanceDB', 'LanceDB', ([], {'connection': 'table', 'embedding': "vector_config['embedding_function']"}), "(connection=table, embedding=vector_config['embedding_function'])\n", (1916, 1981), False, 'from langchain_community.vectorstores import LanceDB, Chroma\n'), ((2793, 2838), 'pinecone.Pinecone', 'Pinecone', ([], {'api_key': "vector_config['db_api_key']"}), "(api_key=vector_config['db_api_key'])\n", (2801, 2838), False, 'from pinecone import Pinecone, ServerlessSpec\n'), ((2300, 2466), 'langchain_community.vectorstores.Chroma', 'Chroma', ([], {'persist_directory': "vector_config['db_name']", 'embedding_function': "vector_config['embedding_function']", 'collection_name': "vector_config['collection_name']"}), "(persist_directory=vector_config['db_name'], embedding_function=\n vector_config['embedding_function'], collection_name=vector_config[\n 'collection_name'])\n", (2306, 2466), False, 'from langchain_community.vectorstores import LanceDB, Chroma\n'), ((3022, 3125), 'langchain_community.vectorstores.Pinecone.from_existing_index', 'LangPinecone.from_existing_index', (["vector_config['index_name']", "vector_config['embedding_function']"], {}), "(vector_config['index_name'], vector_config\n ['embedding_function'])\n", (3054, 3125), True, 'from langchain_community.vectorstores import Pinecone as LangPinecone\n')] |
"""LanceDB vector store."""
import logging
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import (
DEFAULT_TEXT_KEY,
legacy_metadata_dict_to_node,
metadata_dict_to_node,
node_to_metadata_dict,
)
_logger = logging.getLogger(__name__)
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.legacy_filters():
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
text_key: str = DEFAULT_TEXT_KEY,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.text_key = text_key
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=False, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
"metadata": metadata,
}
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
try:
node = metadata_dict_to_node(item.metadata)
node.embedding = list(item.vector)
except Exception:
# deprecated legacy logic for backward compatibility
_logger.debug(
"Failed to parse Node metadata, fallback to legacy logic."
)
metadata, node_info, _relation = legacy_metadata_dict_to_node(
item.metadata, text_key=self.text_key
)
node = TextNode(
text=item.text or "",
id_=item.id,
metadata=metadata,
start_char_idx=node_info.get("start", None),
end_char_idx=node_info.get("end", None),
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((561, 588), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (578, 588), False, 'import logging\n'), ((2970, 2990), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2985, 2990), False, 'import lancedb\n'), ((1325, 1354), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1331, 1354), True, 'import numpy as np\n'), ((3435, 3520), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(False)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=False, flat_metadata=self.flat_metadata\n )\n', (3456, 3520), False, 'from llama_index.vector_stores.utils import DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((1235, 1259), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1241, 1259), True, 'import numpy as np\n'), ((5607, 5643), 'llama_index.vector_stores.utils.metadata_dict_to_node', 'metadata_dict_to_node', (['item.metadata'], {}), '(item.metadata)\n', (5628, 5643), False, 'from llama_index.vector_stores.utils import DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((5971, 6038), 'llama_index.vector_stores.utils.legacy_metadata_dict_to_node', 'legacy_metadata_dict_to_node', (['item.metadata'], {'text_key': 'self.text_key'}), '(item.metadata, text_key=self.text_key)\n', (5999, 6038), False, 'from llama_index.vector_stores.utils import DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((6435, 6471), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (6450, 6471), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
from langchain import PromptTemplate, LLMChain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceBgeEmbeddings
from io import BytesIO
from langchain.document_loaders import PyPDFLoader
import gradio as gr
import lancedb
from langchain.vectorstores import LanceDB
from langchain.document_loaders import ArxivLoader
from langchain.chains import FlareChain
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import os
from langchain.llms import OpenAI
import getpass
os.environ["OPENAI_API_KEY"] = "sk-yourapikeyforopenai"
llm = OpenAI()
model_name = "BAAI/bge-large-en"
model_kwargs = {"device": "cpu"}
encode_kwargs = {"normalize_embeddings": False}
embeddings = HuggingFaceBgeEmbeddings(
model_name=model_name, model_kwargs=model_kwargs, encode_kwargs=encode_kwargs
)
# here is example https://arxiv.org/pdf/2305.06983.pdf
# you need to pass this number to query 2305.06983
# fetch docs from arxiv, in this case it's the FLARE paper
docs = ArxivLoader(query="2305.06983", load_max_docs=2).load()
# instantiate text splitter
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=150)
# split the document into chunks
doc_chunks = text_splitter.split_documents(docs)
# lancedb vectordb
db = lancedb.connect("/tmp/lancedb")
table = db.create_table(
"documentsai",
data=[
{
"vector": embeddings.embed_query("Hello World"),
"text": "Hello World",
"id": "1",
}
],
mode="overwrite",
)
vector_store = LanceDB.from_documents(doc_chunks, embeddings, connection=table)
vector_store_retriever = vector_store.as_retriever()
flare = FlareChain.from_llm(
llm=llm, retriever=vector_store_retriever, max_generation_len=300, min_prob=0.45
)
# Define a function to generate FLARE output based on user input
def generate_flare_output(input_text):
output = flare.run(input_text)
return output
input = gr.Text(
label="Prompt",
show_label=False,
max_lines=1,
placeholder="Enter your prompt",
container=False,
)
iface = gr.Interface(
fn=generate_flare_output,
inputs=input,
outputs="text",
title="My AI bot",
description="FLARE implementation with lancedb & bge embedding.",
)
iface.launch(debug=True, share=True)
| [
"lancedb.connect"
] | [((704, 712), 'langchain.llms.OpenAI', 'OpenAI', ([], {}), '()\n', (710, 712), False, 'from langchain.llms import OpenAI\n'), ((841, 948), 'langchain.embeddings.HuggingFaceBgeEmbeddings', 'HuggingFaceBgeEmbeddings', ([], {'model_name': 'model_name', 'model_kwargs': 'model_kwargs', 'encode_kwargs': 'encode_kwargs'}), '(model_name=model_name, model_kwargs=model_kwargs,\n encode_kwargs=encode_kwargs)\n', (865, 948), False, 'from langchain.embeddings import HuggingFaceBgeEmbeddings\n'), ((1225, 1291), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1500)', 'chunk_overlap': '(150)'}), '(chunk_size=1500, chunk_overlap=150)\n', (1255, 1291), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1400, 1431), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (1415, 1431), False, 'import lancedb\n'), ((1672, 1736), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['doc_chunks', 'embeddings'], {'connection': 'table'}), '(doc_chunks, embeddings, connection=table)\n', (1694, 1736), False, 'from langchain.vectorstores import LanceDB\n'), ((1800, 1905), 'langchain.chains.FlareChain.from_llm', 'FlareChain.from_llm', ([], {'llm': 'llm', 'retriever': 'vector_store_retriever', 'max_generation_len': '(300)', 'min_prob': '(0.45)'}), '(llm=llm, retriever=vector_store_retriever,\n max_generation_len=300, min_prob=0.45)\n', (1819, 1905), False, 'from langchain.chains import FlareChain\n'), ((2077, 2186), 'gradio.Text', 'gr.Text', ([], {'label': '"""Prompt"""', 'show_label': '(False)', 'max_lines': '(1)', 'placeholder': '"""Enter your prompt"""', 'container': '(False)'}), "(label='Prompt', show_label=False, max_lines=1, placeholder=\n 'Enter your prompt', container=False)\n", (2084, 2186), True, 'import gradio as gr\n'), ((2214, 2377), 'gradio.Interface', 'gr.Interface', ([], {'fn': 'generate_flare_output', 'inputs': 'input', 'outputs': '"""text"""', 'title': '"""My AI bot"""', 'description': '"""FLARE implementation with lancedb & bge embedding."""'}), "(fn=generate_flare_output, inputs=input, outputs='text', title=\n 'My AI bot', description=\n 'FLARE implementation with lancedb & bge embedding.')\n", (2226, 2377), True, 'import gradio as gr\n'), ((1124, 1172), 'langchain.document_loaders.ArxivLoader', 'ArxivLoader', ([], {'query': '"""2305.06983"""', 'load_max_docs': '(2)'}), "(query='2305.06983', load_max_docs=2)\n", (1135, 1172), False, 'from langchain.document_loaders import ArxivLoader\n')] |
import os
import re
import instructor
import openai
import pandas as pd
import lancedb
from typing import Optional, List
from pydantic import BaseModel, Field
from tenacity import Retrying, stop_after_attempt, wait_fixed
from src.embedding_models.models import OpenAIEmbeddings
from src.utils.logging import setup_colored_logging
logger = setup_colored_logging(__name__)
class QueryFilterPlan(BaseModel):
"""A revised user query, possibly improved by filtering."""
original_query: str = Field(
...,
description="The original user query."
)
filter: Optional[str] | None = Field(
None,
description="An SQL-like filter inferred from the user query."
)
rephrased_query: str = Field(
...,
description="A rephrased query based on the FILTER fields, or an empty string if no filter is needed.",
)
def filter_df(self, df: pd.DataFrame) -> pd.DataFrame:
"""
Filters the given DataFrame based on the (LLM) defined filter, using LanceDB for querying.
Args:
df (pd.DataFrame): The DataFrame to be filtered.
Returns:
pd.DataFrame: The filtered DataFrame.
"""
if not self.filter:
logger.info(f"No filters have been set! Returning input DataFrame.")
return df
else:
logger.info(f"Input DataFrame has {len(df):,} rows")
logger.info(f"Applying filter(s): {self.filter}")
uri = "../temp-lancedb/pd_table.lance"
db = lancedb.connect(uri)
try:
table = db.create_table("temp_lance", data=df, mode="create")
except:
table = db.create_table("temp_lance", data=df, mode="overwrite")
result_df = (
table.search()
.where(self.filter)
.limit(None)
.to_df()
)
db.drop_database()
logger.info(f"Filtered DataFrame has {len(result_df):,} rows")
return result_df
system_message = f"""
You will receive a QUERY, to be answered based on an EXTREMELY LARGE collection
of documents you DO NOT have access to, but your ASSISTANT does.
You only know that these documents contain text content and FILTERABLE fields in the SCHEMA below:
{{doc_schema}}
Based on the QUERY and the above SCHEMA, your task is to determine a QUERY PLAN,
consisting of:
- a FILTER (can be None) that would help the ASSISTANT to answer the query.
Remember the FILTER can refer to ANY fields in the above SCHEMA.
To get good results, for STRING MATCHES, consider using LIKE instead of =, e.g.
"CEO LIKE '%Jobs%'" instead of "CEO = 'Steve Jobs'"
- a possibly REPHRASED QUERY to be answerable given the FILTER.
Keep in mind that the ASSISTANT does NOT know anything about the FILTER fields,
so the REPHRASED QUERY should NOT mention ANY FILTER fields.
EXAMPLE:
-------
Suppose there is a document-set about crime reports, where:
CONTENT = crime report,
Filterable SCHEMA consists of City, Year, num_deaths.
Then given this ORIGINAL QUERY:
What were the total deaths in shoplifting crimes in Los Angeles in 2023?
A POSSIBLE QUERY PLAN could be:
FILTER: "City LIKE '%Los Angeles%' AND Year = 2023"
REPHRASED QUERY: "shoplifting crime" --> this will be used to MATCH content of docs
[NOTE: we dropped the FILTER fields City and Year since the
ASSISTANT does not know about them and only uses the query to
match the CONTENT of the docs.]
------------- END OF EXAMPLE ----------------
The FILTER must be a SQL-like condition, e.g.
"year > 2000 AND genre = 'ScienceFiction'".
To ensure you get useful results, you should make your FILTER
NOT TOO STRICT, e.g. look for approximate match using LIKE, etc.
E.g. "CEO LIKE '%Jobs%'" instead of "CEO = 'Steve Jobs'"
"""
def describe_dataframe(
input_df: pd.DataFrame, filter_fields: List[str] = [], n_vals: int = 10
) -> str:
"""
Generates a description of the columns in the dataframe,
along with a listing of up to `n_vals` unique values for each column.
Intended to be used to insert into an LLM context so it can generate
appropriate queries or filters on the df.
Args:
df (pd.DataFrame): The dataframe to describe.
filter_fields (list): A list of fields that can be used for filtering.
When non-empty, the values-list will be restricted to these.
n_vals (int): How many unique values to show for each column.
Returns:
str: A description of the dataframe.
"""
# Convert column names to snake_case for compatibility with LanceDB
df = input_df[filter_fields]
description = []
for column in df.columns.to_list():
unique_values = df[column].dropna().unique()
unique_count = len(unique_values)
if unique_count > n_vals:
displayed_values = unique_values[:n_vals]
more_count = unique_count - n_vals
values_desc = f" Values - {displayed_values}, ... {more_count} more"
else:
values_desc = f" Values - {unique_values}"
col_type = "string" if df[column].dtype == "object" else df[column].dtype
col_desc = f"* {column} ({col_type}); {values_desc}"
description.append(col_desc)
all_cols = "\n".join(description)
return f"""
Name of each field, its type and unique values (up to {n_vals}):
{all_cols}
"""
def generate_query_plan(
input_df: pd.DataFrame, query: str, filter_fields: List[str], n_vals: int = 20
) -> QueryFilterPlan:
client = instructor.patch(openai.OpenAI())
df = input_df[filter_fields]
filter_string = describe_dataframe(
input_df=df,
filter_fields=filter_fields,
n_vals=n_vals,
)
logger.info(f"Schema shown to LLM: {filter_string}")
return client.chat.completions.create(
model="gpt-4-1106-preview",
response_model=QueryFilterPlan,
max_retries=Retrying(
stop=stop_after_attempt(5),
wait=wait_fixed(1),
),
messages=[
{
"role": "system",
"content": system_message.format(doc_schema=filter_string),
},
{
"role": "user",
"content": f"Here is the user query:\n\nQUERY:{query}",
},
],
)
def auto_filter_vector_search(
df: pd.DataFrame,
query: str,
text_column: str,
embeddings_column: str,
filter_fields: List[str],
top_k: int = 20
) -> pd.DataFrame:
query_plan = generate_query_plan(
input_df=df,
query=query,
filter_fields=filter_fields,
)
if not query_plan.filter:
logger.info(f"No filters were identified for query: {query}")
search_query = query_plan.original_query
else:
logger.info(f"Applying filter(s): {query_plan.filter}")
logger.info(f"Revised query: {query_plan.rephrased_query}")
search_query = query_plan.rephrased_query
df.rename(columns={embeddings_column: "vector"}, inplace=True)
uri = "../temp-lancedb/pd_table.lance"
db = lancedb.connect(uri)
filter_fields.append(text_column)
filter_fields.append("vector")
try:
table = db.create_table("temp_lance", data=df[filter_fields], mode="create")
except:
table = db.create_table("temp_lance", data=df[filter_fields], mode="overwrite")
embeddings_model = OpenAIEmbeddings()
embedder = embeddings_model.embedding_fn()
query_vector = embedder(search_query)
if query_plan.filter:
result = (
table.search(query_vector[0]) \
.metric("cosine") \
.where(query_plan.filter, prefilter=True) \
.limit(top_k) \
.to_df()
)
else:
result = (
table.search(query_vector[0]) \
.metric("cosine") \
.limit(top_k) \
.to_df()
)
result.rename(columns={"vector": embeddings_column}, inplace=True)
logger.info(f"Vector search yielded a DataFrame with {len(result):,} rows")
return result
def auto_filter_fts_search(
df: pd.DataFrame,
query: str,
text_column: str,
embeddings_column: str,
filter_fields: List[str],
top_k: int = 20
) -> pd.DataFrame:
"""
Performs a full-text search (FTS) on the given DataFrame based on the specified query and filter fields.
Args:
df (pd.DataFrame): The DataFrame to search.
query (str): The query string to search for.
text_column (str): The name of the column containing text to search.
embeddings_column (str): The name of the column containing embeddings.
filter_fields (List[str]): A list of fields to filter the search results.
top_k (int): The maximum number of search results to return.
Returns:
pd.DataFrame: A DataFrame containing the top_k search results.
"""
query_plan = generate_query_plan(
input_df=df,
query=query,
filter_fields=filter_fields,
)
if not query_plan.filter:
logger.info(f"No filters were identified for query: {query}")
else:
logger.info(f"Applying filter(s): {query_plan.filter}")
# Check if a revised query exists and is not an empty string, use it if so
if query_plan.rephrased_query and query_plan.rephrased_query.strip():
logger.info(f"Revised query: {query_plan.rephrased_query}")
search_query = query_plan.rephrased_query
else:
search_query = query_plan.original_query
df.rename(columns={embeddings_column: "vector"}, inplace=True)
uri = "../temp-lancedb/pd_table.lance"
db = lancedb.connect(uri)
filter_fields.append(text_column)
filter_fields.append("vector")
try:
table = db.create_table("temp_lance", data=df[filter_fields], mode="create")
except:
table = db.create_table("temp_lance", data=df[filter_fields], mode="overwrite")
table.create_fts_index(text_column, replace=True)
# Clean up query: replace all newlines with spaces in query,
# force special search keywords to lower case, remove quotes,
# so it's not interpreted as search syntax
query_clean = (
search_query.replace("\n", " ")
.replace("AND", "and")
.replace("OR", "or")
.replace("NOT", "not")
.replace("'", "")
.replace('"', "")
)
if query_plan.filter:
result = (
table.search(query_clean, query_type="fts") \
.where(query_plan.filter) \
.limit(top_k) \
.to_df()
)
else:
result = (
table.search(query_clean, query_type="fts") \
.limit(top_k) \
.to_df()
)
result.rename(columns={"vector": embeddings_column}, inplace=True)
logger.info(f"Full Text Search (FTS) search yielded a DataFrame with {len(result):,} rows")
return result
| [
"lancedb.connect"
] | [((341, 372), 'src.utils.logging.setup_colored_logging', 'setup_colored_logging', (['__name__'], {}), '(__name__)\n', (362, 372), False, 'from src.utils.logging import setup_colored_logging\n'), ((504, 554), 'pydantic.Field', 'Field', (['...'], {'description': '"""The original user query."""'}), "(..., description='The original user query.')\n", (509, 554), False, 'from pydantic import BaseModel, Field\n'), ((613, 688), 'pydantic.Field', 'Field', (['None'], {'description': '"""An SQL-like filter inferred from the user query."""'}), "(None, description='An SQL-like filter inferred from the user query.')\n", (618, 688), False, 'from pydantic import BaseModel, Field\n'), ((739, 863), 'pydantic.Field', 'Field', (['...'], {'description': '"""A rephrased query based on the FILTER fields, or an empty string if no filter is needed."""'}), "(..., description=\n 'A rephrased query based on the FILTER fields, or an empty string if no filter is needed.'\n )\n", (744, 863), False, 'from pydantic import BaseModel, Field\n'), ((7186, 7206), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (7201, 7206), False, 'import lancedb\n'), ((7506, 7524), 'src.embedding_models.models.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (7522, 7524), False, 'from src.embedding_models.models import OpenAIEmbeddings\n'), ((9778, 9798), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (9793, 9798), False, 'import lancedb\n'), ((1544, 1564), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (1559, 1564), False, 'import lancedb\n'), ((5614, 5629), 'openai.OpenAI', 'openai.OpenAI', ([], {}), '()\n', (5627, 5629), False, 'import openai\n'), ((6016, 6037), 'tenacity.stop_after_attempt', 'stop_after_attempt', (['(5)'], {}), '(5)\n', (6034, 6037), False, 'from tenacity import Retrying, stop_after_attempt, wait_fixed\n'), ((6056, 6069), 'tenacity.wait_fixed', 'wait_fixed', (['(1)'], {}), '(1)\n', (6066, 6069), False, 'from tenacity import Retrying, stop_after_attempt, wait_fixed\n')] |
import logging
import lancedb
import os
from pathlib import Path
DB_TABLE_NAME = "split_files_db"
# Setting up the logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# db
db_uri = os.path.join(Path(__file__).parents[1], ".lancedb")
db = lancedb.connect(db_uri)
table = db.open_table(DB_TABLE_NAME)
| [
"lancedb.connect"
] | [((126, 165), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (145, 165), False, 'import logging\n'), ((175, 202), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (192, 202), False, 'import logging\n'), ((276, 299), 'lancedb.connect', 'lancedb.connect', (['db_uri'], {}), '(db_uri)\n', (291, 299), False, 'import lancedb\n'), ((232, 246), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (236, 246), False, 'from pathlib import Path\n')] |
"""
Chatbot for talking to Podcast using Langchain, Ollama and LanceDB
"""
from langchain.document_loaders import WikipediaLoader
import pandas as pd
from langchain.memory import ConversationSummaryMemory
import lancedb
from langchain.vectorstores import LanceDB
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chat_models import ChatOllama
from langchain.chains import ConversationalRetrievalChain
def lanceDBConnection(embed):
db = lancedb.connect("/tmp/lancedb")
table = db.create_table(
"pdf_search",
data=[{"vector": embed.embed_query("Hello World"), "text": "Hello World"}],
mode="overwrite",
)
return table
def vectorStoreSetup(query, OPENAI_KEY):
docs = WikipediaLoader(query=query, load_max_docs=2).load()
# chunking
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(docs)
# OpenAI embeddings
embed = OpenAIEmbeddings(openai_api_key=OPENAI_KEY)
# LanceDB as vector store
table = lanceDBConnection(embed)
vectorstore = LanceDB.from_documents(
documents=all_splits,
embedding=OpenAIEmbeddings(openai_api_key=OPENAI_KEY),
connection=table,
)
return vectorstore
def retrieverSetup(text, OPENAI_KEY):
vectorstore = vectorStoreSetup(text, OPENAI_KEY)
# define ChatOllama: by default takes llama2-4bit quantized model
llm = ChatOllama()
memory = ConversationSummaryMemory(
llm=llm, memory_key="chat_history", return_messages=True
)
retriever = vectorstore.as_retriever()
# define Retrieval Chain for retriver
qa = ConversationalRetrievalChain.from_llm(llm, retriever=retriever, memory=memory)
return qa
def chat(qa, question):
# chat query
r = qa.run({"question": question})
return r
| [
"lancedb.connect"
] | [((525, 556), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (540, 556), False, 'import lancedb\n'), ((883, 946), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(500)', 'chunk_overlap': '(0)'}), '(chunk_size=500, chunk_overlap=0)\n', (913, 946), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1036, 1079), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'OPENAI_KEY'}), '(openai_api_key=OPENAI_KEY)\n', (1052, 1079), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((1510, 1522), 'langchain.chat_models.ChatOllama', 'ChatOllama', ([], {}), '()\n', (1520, 1522), False, 'from langchain.chat_models import ChatOllama\n'), ((1536, 1623), 'langchain.memory.ConversationSummaryMemory', 'ConversationSummaryMemory', ([], {'llm': 'llm', 'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(llm=llm, memory_key='chat_history',\n return_messages=True)\n", (1561, 1623), False, 'from langchain.memory import ConversationSummaryMemory\n'), ((1728, 1806), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', (['llm'], {'retriever': 'retriever', 'memory': 'memory'}), '(llm, retriever=retriever, memory=memory)\n', (1765, 1806), False, 'from langchain.chains import ConversationalRetrievalChain\n'), ((795, 840), 'langchain.document_loaders.WikipediaLoader', 'WikipediaLoader', ([], {'query': 'query', 'load_max_docs': '(2)'}), '(query=query, load_max_docs=2)\n', (810, 840), False, 'from langchain.document_loaders import WikipediaLoader\n'), ((1237, 1280), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'OPENAI_KEY'}), '(openai_api_key=OPENAI_KEY)\n', (1253, 1280), False, 'from langchain.embeddings import OpenAIEmbeddings\n')] |
import os
import dotenv
import gradio as gr
import lancedb
import logging
from langchain.embeddings.cohere import CohereEmbeddings
from langchain.llms import Cohere
from langchain.prompts import PromptTemplate
from langchain.chains import RetrievalQA
from langchain.vectorstores import LanceDB
from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader
import argostranslate.package
import argostranslate.translate
# Configuration Management
dotenv.load_dotenv(".env")
DB_PATH = "/tmp/lancedb"
COHERE_MODEL_NAME = "multilingual-22-12"
LANGUAGE_ISO_CODES = {
"English": "en",
"Hindi": "hi",
"Turkish": "tr",
"French": "fr",
}
# Logging Configuration
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def initialize_documents_and_embeddings(input_file_path):
"""
Initialize documents and their embeddings from a given file.
Parameters:
- input_file_path (str): The path to the input file. Supported formats are .txt and .pdf.
Returns:
- tuple: A tuple containing a list of texts split from the document and the embeddings object.
"""
file_extension = os.path.splitext(input_file_path)[1]
if file_extension == ".txt":
logger.info("txt file processing")
# Handle text file
loader = TextLoader(input_file_path)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
texts = text_splitter.split_documents(documents)
elif file_extension == ".pdf":
logger.info("pdf file processing")
# Handle PDF file
loader = PyPDFLoader(input_file_path)
texts = loader.load_and_split()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
texts = text_splitter.split_documents(texts)
else:
raise ValueError(
"Unsupported file type. Supported files are .txt and .pdf only."
)
embeddings = CohereEmbeddings(model=COHERE_MODEL_NAME)
return texts, embeddings
# Database Initialization
def initialize_database(texts, embeddings):
"""
Initialize and populate a LanceDB database with documents and their embeddings.
Parameters:
- texts (list): A list of texts to be stored in the database.
- embeddings (CohereEmbeddings): An embeddings object used to generate vector embeddings for the texts.
Returns:
- LanceDB: An instance of LanceDB with the documents and their embeddings stored.
"""
db = lancedb.connect(DB_PATH)
table = db.create_table(
"multiling-rag",
data=[
{
"vector": embeddings.embed_query("Hello World"),
"text": "Hello World",
"id": "1",
}
],
mode="overwrite",
)
return LanceDB.from_documents(texts, embeddings, connection=table)
# Translation Function
def translate_text(text, from_code, to_code):
"""
Translate a given text from one language to another.
Parameters:
- text (str): The text to translate.
- from_code (str): The ISO language code of the source language.
- to_code (str): The ISO language code of the target language.
Returns:
- str: The translated text.
"""
try:
argostranslate.package.update_package_index()
available_packages = argostranslate.package.get_available_packages()
package_to_install = next(
filter(
lambda x: x.from_code == from_code and x.to_code == to_code,
available_packages,
)
)
argostranslate.package.install_from_path(package_to_install.download())
return argostranslate.translate.translate(text, from_code, to_code)
except Exception as e:
logger.error(f"Error in translate_text: {str(e)}")
return "Translation error"
prompt_template = """Text: {context}
Question: {question}
Answer the question based on the text provided. If the text doesn't contain the answer, reply that the answer is not available."""
PROMPT = PromptTemplate(
template=prompt_template, input_variables=["context", "question"]
)
# Question Answering Function
def answer_question(question, input_language, output_language, db):
"""
Answer a given question by retrieving relevant information from a database,
translating the question and answer if necessary.
Parameters:
- question (str): The question to answer.
- input_language (str): The language of the input question.
- output_language (str): The desired language of the answer.
- db (LanceDB): The LanceDB instance to use for information retrieval.
Returns:
- str: The answer to the question, in the desired output language
"""
try:
input_lang_code = LANGUAGE_ISO_CODES[input_language]
output_lang_code = LANGUAGE_ISO_CODES[output_language]
question_in_english = (
translate_text(question, from_code=input_lang_code, to_code="en")
if input_language != "English"
else question
)
prompt = PromptTemplate(
template=prompt_template, input_variables=["context", "question"]
)
qa = RetrievalQA.from_chain_type(
llm=Cohere(model="command", temperature=0),
chain_type="stuff",
retriever=db.as_retriever(),
chain_type_kwargs={"prompt": prompt},
return_source_documents=True,
)
answer = qa({"query": question_in_english})
result_in_english = answer["result"].replace("\n", "").replace("Answer:", "")
return (
translate_text(result_in_english, from_code="en", to_code=output_lang_code)
if output_language != "English"
else result_in_english
)
except Exception as e:
logger.error(f"Error in answer_question: {str(e)}")
return "An error occurred while processing your question. Please try again."
def setup_gradio_interface(db):
"""
Setup a Gradio interface for interacting with the multilingual chatbot.
Parameters:
- db (LanceDB): The database instance to use for information retrieval.
Returns:
- gr.Interface: A Gradio interface object for the chatbot.
"""
return gr.Interface(
fn=lambda question, input_language, output_language: answer_question(
question, input_language, output_language, db
),
inputs=[
gr.Textbox(lines=2, placeholder="Type your question here..."),
gr.Dropdown(list(LANGUAGE_ISO_CODES.keys()), label="Input Language"),
gr.Dropdown(list(LANGUAGE_ISO_CODES.keys()), label="Output Language"),
],
outputs="text",
title="Multilingual Chatbot",
description="Ask any question in your chosen language and get an answer in the language of your choice.",
)
# Main Function
def main():
INPUT_FILE_PATH = "healthy-diet-fact-sheet-394.pdf"
texts, embeddings = initialize_documents_and_embeddings(INPUT_FILE_PATH)
db = initialize_database(texts, embeddings)
iface = setup_gradio_interface(db)
iface.launch(share=True, debug=True)
if __name__ == "__main__":
main()
| [
"lancedb.connect"
] | [((563, 589), 'dotenv.load_dotenv', 'dotenv.load_dotenv', (['""".env"""'], {}), "('.env')\n", (581, 589), False, 'import dotenv\n'), ((788, 827), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (807, 827), False, 'import logging\n'), ((837, 864), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (854, 864), False, 'import logging\n'), ((4194, 4279), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'prompt_template', 'input_variables': "['context', 'question']"}), "(template=prompt_template, input_variables=['context',\n 'question'])\n", (4208, 4279), False, 'from langchain.prompts import PromptTemplate\n'), ((2089, 2130), 'langchain.embeddings.cohere.CohereEmbeddings', 'CohereEmbeddings', ([], {'model': 'COHERE_MODEL_NAME'}), '(model=COHERE_MODEL_NAME)\n', (2105, 2130), False, 'from langchain.embeddings.cohere import CohereEmbeddings\n'), ((2632, 2656), 'lancedb.connect', 'lancedb.connect', (['DB_PATH'], {}), '(DB_PATH)\n', (2647, 2656), False, 'import lancedb\n'), ((2939, 2998), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['texts', 'embeddings'], {'connection': 'table'}), '(texts, embeddings, connection=table)\n', (2961, 2998), False, 'from langchain.vectorstores import LanceDB\n'), ((1251, 1284), 'os.path.splitext', 'os.path.splitext', (['input_file_path'], {}), '(input_file_path)\n', (1267, 1284), False, 'import os\n'), ((1408, 1435), 'langchain.document_loaders.TextLoader', 'TextLoader', (['input_file_path'], {}), '(input_file_path)\n', (1418, 1435), False, 'from langchain.document_loaders import TextLoader\n'), ((1494, 1558), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(300)', 'chunk_overlap': '(50)'}), '(chunk_size=300, chunk_overlap=50)\n', (1524, 1558), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((5222, 5307), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'prompt_template', 'input_variables': "['context', 'question']"}), "(template=prompt_template, input_variables=['context',\n 'question'])\n", (5236, 5307), False, 'from langchain.prompts import PromptTemplate\n'), ((1737, 1765), 'langchain_community.document_loaders.PyPDFLoader', 'PyPDFLoader', (['input_file_path'], {}), '(input_file_path)\n', (1748, 1765), False, 'from langchain_community.document_loaders import PyPDFLoader\n'), ((1830, 1894), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(300)', 'chunk_overlap': '(50)'}), '(chunk_size=300, chunk_overlap=50)\n', (1860, 1894), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((5384, 5422), 'langchain.llms.Cohere', 'Cohere', ([], {'model': '"""command"""', 'temperature': '(0)'}), "(model='command', temperature=0)\n", (5390, 5422), False, 'from langchain.llms import Cohere\n'), ((6603, 6664), 'gradio.Textbox', 'gr.Textbox', ([], {'lines': '(2)', 'placeholder': '"""Type your question here..."""'}), "(lines=2, placeholder='Type your question here...')\n", (6613, 6664), True, 'import gradio as gr\n')] |
import lancedb
#vectorstore functions
class Vectorstore():
"""A class to interact with the vectorstore."""
def __init__(self,) -> None:
"""Initialize the vectorstore object."""
uri = "data/sample-lancedb"
db = lancedb.connect(uri)
self.name = name | [
"lancedb.connect"
] | [((251, 271), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (266, 271), False, 'import lancedb\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.filters:
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text,
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2773, 2793), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2788, 2793), False, 'import lancedb\n'), ((1170, 1199), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1176, 1199), True, 'import numpy as np\n'), ((3178, 3257), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=True, flat_metadata=self.flat_metadata)\n', (3199, 3257), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((1080, 1104), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1086, 1104), True, 'import numpy as np\n'), ((5479, 5515), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5494, 5515), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
from flask import Flask, jsonify, request, json, send_from_directory
import os
import openai
import pandas as pd
import base64
import os
import requests
import numpy as np
# import google.cloud.texttospeech as tts
import lancedb
from flask_cors import CORS
# os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = 'service.json'
# os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = os.getenv("GCP")
openai.api_key = os.getenv("OPENAI_API_KEY")
app = Flask(__name__)
CORS(app, resources={r"/*": {"origins": "*"}})
stories_file = 'data/stories.csv'
session_file = 'data/session.csv'
uri = "./data/lancedb"
db = lancedb.connect(uri)
try:
db.create_table('mytale', data=[{"vector":[0,0],"id": "0", "title": "", "story": "", "img":['','','',''], "audio":""}])
except:
pass
def insertIntoLance(data):
t = db.open_table('mytale')
t.add(data=data)
print('inserted into lance')
return t
def readLance():
t = db.open_table('mytale')
#print(t.head())
print('read lance')
return t.head()
@app.route('/test', methods=['GET'])
def getLance():
data = readLance()
id_values = data['id'].to_pandas().tolist()
title_values = data['title'].to_pandas().tolist()
story_values = data['story'].to_pandas().tolist()
audio_values = data['audio'].to_pandas().tolist()
img_values = data['img'].to_pandas().tolist()
# Construct a list of dictionaries with 'id', 'title', 'story', and 'audio' keys
final = []
for i in range(1,len(id_values)):
entry = {
'id': id_values[i],
'title': title_values[i],
'story': f"""{story_values[i]}""",
'img':[img_values[i][0],img_values[i][1],img_values[i][2],img_values[i][3]],
'audio': audio_values[i]
}
final.append(entry)
# Convert the list of dictionaries to JSON format
return final
# if not os.path.exists(stories_file):
# df = pd.DataFrame({
# "id": [],
# "title": [],
# "story": [],
# "img": []
# })
# df.to_csv(stories_file, index=False)
if not os.path.exists(session_file):
df = pd.DataFrame({
"id": [],
"sess_id": [],
"story_id": [],
"role": [],
"content": []
})
df.to_csv(session_file, index=False)
# stories_df = pd.read_csv(stories_file)
session_df = pd.read_csv(session_file)
def generate_story(topic: str) -> str:
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": f"Generate a 4 paragraph children's story with title about {topic} that contains a moral."}
]
)
content = completion.choices[0].message.content
content = content.encode().decode('unicode_escape')
title = content.split('\n')[0]
title = title.replace('Title: ', '')
story = content[content.find('\n'):]
story = story.lstrip()
return title, story
def generate_prompts(story: str):
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": f"Create four text to image prompts, seperated by new line, that will be suitable as images of the below given story such that each image represents a paragraph in the story. Do not include the character names, instead include only the characters physical description.\n\n{story}"}
]
)
prompts = completion.choices[0].message.content
prompts = prompts.encode().decode('unicode_escape')
prompts = prompts.split('\n')
ans = []
for i in prompts:
#t = i.message.content
#t = t.encode().decode('unicode_escape')
if ':' in i:
i = i[i.find(':')+1:]
i = i.strip()
if(i != ""):
ans.append(i)
content = completion.choices[0].message.content
content = content.encode().decode('unicode_escape')
if ':' in content:
content = content[content.find(':')+1:]
content = content.strip()
return ans
def generate_image(prompt: str):
engine_id = "stable-diffusion-512-v2-1"
api_host = os.getenv('API_HOST', 'https://api.stability.ai')
api_key = os.getenv("STABILITYAI_API_KEY")
if api_key is None:
raise Exception("Missing Stability API key.")
response = requests.post(
f"{api_host}/v1/generation/{engine_id}/text-to-image",
headers={
"Content-Type": "application/json",
"Accept": "application/json",
"Authorization": f"Bearer {api_key}"
},
json={
"text_prompts": [
{
"text": f"{prompt}"
}
],
"cfg_scale": 7,
"clip_guidance_preset": "FAST_BLUE",
"height": 512,
"width": 512,
"samples": 1,
"steps": 30,
},
)
if response.status_code != 200:
raise Exception(
"Non-200 response for image generation: " + str(response.text))
data = response.json()
for i, image in enumerate(data["artifacts"]):
return image["base64"]
def save_story(title: str, story: str, img: [],audio_filename: str):
img_filename=[]
for i in range(len(img)):
img_filename.append(f"./images/{title+str(i)}.png")
with open(img_filename[i], "wb") as f:
f.write(base64.b64decode(img[i]))
global stories_df
images_dest=[]
for i in range(len(img)):
# images_dest.append(request.root_url + 'images/' + title+str(i) + '.png')
images_dest.append('images/' + title+str(i) + '.png')
images_dest = np.array(images_dest)
# temp_df = pd.DataFrame({
# "id": [len(stories_df)+1],
# "title": [title],
# "story": [story],
# "img": [images_dest.tolist()],
# "audio": [request.root_url + 'audios/' + title + '.wav']
# })
#[{"vector": [1, 1], "id": 2, "title": "test", "story": "test", "img": ['a', 'b', 'c', 'd'], "audio": "asdasd"}]
insertIntoLance([{
"vector":[len(getLance())+1, len(getLance())+1],
# "id": len(stories_df)+1,
"id": len(getLance())+1,
"title": title,
"story": story.replace("'", "\\'"),
"img": images_dest.tolist(),
"audio": request.root_url + 'audios/' + title + '.wav'
}])
# stories_df = pd.concat([stories_df, temp_df], ignore_index=True)
# stories_df.to_csv(stories_file, index=False)
def get_followup_response(session_id: int, story_id: int, question: str):
global session_df
# story = stories_df[stories_df['id'] == story_id]['story'].values[0]
# t = getLance()
# print("t", t)
# print(f"story id {story_id}")
# story = t[story_id+1]['story']
print("story_id", story_id)
data = getLance()
target_story = next((story for story in data if int(story["id"]) == story_id), None)
story = target_story["story"]
print("story", story)
system_msg = f"You are an assistant that answers the questions to the children's "\
"story given below. You should answer the questions descriptively in a "\
"way that a child can understand them. If the question asked is unrelated "\
"to the story, do not answer the question and instead reply by asking the "\
"user to ask questions related to the story."\
"\n\n"\
f"Story: {story}"
temp_df = pd.DataFrame({
"id": [len(session_df)+1],
"sess_id": [session_id],
"story_id": [story_id],
"role": ["user"],
"content": [question]
})
session_df = pd.concat([session_df, temp_df], ignore_index=True)
messages = session_df[session_df['sess_id']
== session_id][["id", "role", "content"]]
messages = messages.sort_values(by=['id'])
messages = messages[['role', 'content']]
messages = messages.to_dict('records')
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": system_msg},
*messages
]
)
content = completion.choices[0].message.content
content = content.encode().decode('unicode_escape')
temp_df = pd.DataFrame({
"id": [len(session_df)+1],
"sess_id": [session_id],
"story_id": [story_id],
"role": ["assistant"],
"content": [content]
})
session_df = pd.concat([session_df, temp_df], ignore_index=True)
session_df.to_csv(session_file, index=False)
return content
def text_to_wav(text: str, title, dest, voice_name = "en-IN-Wavenet-A"):
language_code = "-".join(voice_name.split("-")[:2])
text_input = tts.SynthesisInput(text=text)
voice_params = tts.VoiceSelectionParams(
language_code=language_code, name=voice_name
)
audio_config = tts.AudioConfig(audio_encoding=tts.AudioEncoding.LINEAR16,
speaking_rate=0.8)
client = tts.TextToSpeechClient()
response = client.synthesize_speech(
input=text_input,
voice=voice_params,
audio_config=audio_config,
)
filename = f"{dest + '/' + title}.wav"
with open(filename, "wb") as out:
out.write(response.audio_content)
print(f'Generated speech saved to "{filename}"')
return filename
@app.route('/', methods=['GET'])
def index():
return jsonify({'message': 'Hello World!'})
@app.route('/images/<path:path>', methods=['GET'])
def get_image(path):
return send_from_directory('images', path)
@app.route('/audios/<path:path>', methods=['GET'])
def get_audio(path):
return send_from_directory('audios', path)
@app.route('/generate', methods=['GET'])
def generate():
topic = request.args.get('topic')
title, story = generate_story(topic)
print(f"Title: {title}")
print(f"Story: {story}")
prompts = generate_prompts(story)
print(f"Prompts: {prompts}")
img = []
for i in range(len(prompts)):
img.append(generate_image(prompts[i]))
print("Image generated")
# audio_file = text_to_wav(story, title, "./audios")
audio_file = ""
print("Audio generated")
save_story(title, story, img, audio_file)
t = getLance()
tl = len(t)
return jsonify({'title': title, 'story': story, "id": tl,
'img': request.root_url + 'images/' + title + '.png', 'audio': request.root_url + 'audios/' + title + '.wav'})
@app.route('/get_story', methods=['GET'])
def get_story():
story_id = int(request.args.get('id'))
t = getLance()
return t[story_id]['story']
# story = stories_df[stories_df['id'] == story_id].to_dict('records')[0]
# if(type(story['img']) == str):
# story['img'] = ast.literal_eval(story['img'])
return jsonify({'story': story})
@app.route('/get_n_stories', methods=['GET'])
def get_n_stories():
# n = int(request.args.get('n'))
# sampled_stories = stories_df.sample(n=n).copy()
# for idx, story in sampled_stories.iterrows():
# if(type(sampled_stories.at[idx, 'img']) == str):
# sampled_stories.at[idx, 'img'] = ast.literal_eval(story['img'])
# stories = sampled_stories.to_dict('records')
return jsonify({'stories': getLance()})
return jsonify({'stories': stories})
@app.route('/get_story_count', methods=['GET'])
def get_story_count():
return jsonify({'count': len(getLance())})
@app.route('/get_followup', methods=['GET'])
def get_followup():
session_id = int(request.args.get('session_id'))
story_id = int(request.args.get('story_id'))
question = request.args.get('question')
response = get_followup_response(session_id, story_id, question)
# audio_file = text_to_wav(response, f"temp", "./audios")
audio_file = ""
return jsonify({'response': response, 'audio': request.root_url + 'audios/' + 'temp' + '.wav'})
def transcribe_file(audio):
"""Transcribe the given audio file."""
from google.cloud import speech
client = speech.SpeechClient()
audio = speech.RecognitionAudio(content=audio)
config = speech.RecognitionConfig(
encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
sample_rate_hertz=48000,
language_code="en-US",
)
response = client.recognize(config=config, audio=audio)
# Each result is for a consecutive portion of the audio. Iterate through
# them to get the transcripts for the entire audio file.
for result in response.results:
# The first alternative is the most likely one for this portion.
print("Transcript: {}".format(result.alternatives[0].transcript))
return result.alternatives[0].transcript
@app.route('/post_followup_audio', methods=['POST'])
def get_text():
# get the audio data from form
audio_file = request.files['audio']
sess_id = request.form['session_id']
story_id = request.form['story_id']
text = transcribe_file(audio_file.read())
if text is None:
return jsonify({'response': 'Sorry, I could not understand you. Please try again.'})
response = get_followup_response(sess_id, story_id, text)
return jsonify({'response': response})
if __name__ == '__main__':
# app.run()
app.run(debug=True) | [
"lancedb.connect"
] | [((407, 434), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (416, 434), False, 'import os\n'), ((441, 456), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (446, 456), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((457, 502), 'flask_cors.CORS', 'CORS', (['app'], {'resources': "{'/*': {'origins': '*'}}"}), "(app, resources={'/*': {'origins': '*'}})\n", (461, 502), False, 'from flask_cors import CORS\n'), ((603, 623), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (618, 623), False, 'import lancedb\n'), ((2347, 2372), 'pandas.read_csv', 'pd.read_csv', (['session_file'], {}), '(session_file)\n', (2358, 2372), True, 'import pandas as pd\n'), ((2083, 2111), 'os.path.exists', 'os.path.exists', (['session_file'], {}), '(session_file)\n', (2097, 2111), False, 'import os\n'), ((2122, 2208), 'pandas.DataFrame', 'pd.DataFrame', (["{'id': [], 'sess_id': [], 'story_id': [], 'role': [], 'content': []}"], {}), "({'id': [], 'sess_id': [], 'story_id': [], 'role': [],\n 'content': []})\n", (2134, 2208), True, 'import pandas as pd\n'), ((2430, 2626), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': '"""gpt-3.5-turbo"""', 'messages': '[{\'role\': \'user\', \'content\':\n f"Generate a 4 paragraph children\'s story with title about {topic} that contains a moral."\n }]'}), '(model=\'gpt-3.5-turbo\', messages=[{\'role\':\n \'user\', \'content\':\n f"Generate a 4 paragraph children\'s story with title about {topic} that contains a moral."\n }])\n', (2458, 2626), False, 'import openai\n'), ((2987, 3375), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': '"""gpt-3.5-turbo"""', 'messages': '[{\'role\': \'user\', \'content\':\n f"""Create four text to image prompts, seperated by new line, that will be suitable as images of the below given story such that each image represents a paragraph in the story. Do not include the character names, instead include only the characters physical description.\n\n{story}"""\n }]'}), '(model=\'gpt-3.5-turbo\', messages=[{\'role\':\n \'user\', \'content\':\n f"""Create four text to image prompts, seperated by new line, that will be suitable as images of the below given story such that each image represents a paragraph in the story. Do not include the character names, instead include only the characters physical description.\n\n{story}"""\n }])\n', (3015, 3375), False, 'import openai\n'), ((4117, 4166), 'os.getenv', 'os.getenv', (['"""API_HOST"""', '"""https://api.stability.ai"""'], {}), "('API_HOST', 'https://api.stability.ai')\n", (4126, 4166), False, 'import os\n'), ((4181, 4213), 'os.getenv', 'os.getenv', (['"""STABILITYAI_API_KEY"""'], {}), "('STABILITYAI_API_KEY')\n", (4190, 4213), False, 'import os\n'), ((4309, 4669), 'requests.post', 'requests.post', (['f"""{api_host}/v1/generation/{engine_id}/text-to-image"""'], {'headers': "{'Content-Type': 'application/json', 'Accept': 'application/json',\n 'Authorization': f'Bearer {api_key}'}", 'json': "{'text_prompts': [{'text': f'{prompt}'}], 'cfg_scale': 7,\n 'clip_guidance_preset': 'FAST_BLUE', 'height': 512, 'width': 512,\n 'samples': 1, 'steps': 30}"}), "(f'{api_host}/v1/generation/{engine_id}/text-to-image',\n headers={'Content-Type': 'application/json', 'Accept':\n 'application/json', 'Authorization': f'Bearer {api_key}'}, json={\n 'text_prompts': [{'text': f'{prompt}'}], 'cfg_scale': 7,\n 'clip_guidance_preset': 'FAST_BLUE', 'height': 512, 'width': 512,\n 'samples': 1, 'steps': 30})\n", (4322, 4669), False, 'import requests\n'), ((5650, 5671), 'numpy.array', 'np.array', (['images_dest'], {}), '(images_dest)\n', (5658, 5671), True, 'import numpy as np\n'), ((7674, 7725), 'pandas.concat', 'pd.concat', (['[session_df, temp_df]'], {'ignore_index': '(True)'}), '([session_df, temp_df], ignore_index=True)\n', (7683, 7725), True, 'import pandas as pd\n'), ((7996, 8116), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': '"""gpt-3.5-turbo"""', 'messages': "[{'role': 'system', 'content': system_msg}, *messages]"}), "(model='gpt-3.5-turbo', messages=[{'role':\n 'system', 'content': system_msg}, *messages])\n", (8024, 8116), False, 'import openai\n'), ((8493, 8544), 'pandas.concat', 'pd.concat', (['[session_df, temp_df]'], {'ignore_index': '(True)'}), '([session_df, temp_df], ignore_index=True)\n', (8502, 8544), True, 'import pandas as pd\n'), ((9462, 9498), 'flask.jsonify', 'jsonify', (["{'message': 'Hello World!'}"], {}), "({'message': 'Hello World!'})\n", (9469, 9498), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((9583, 9618), 'flask.send_from_directory', 'send_from_directory', (['"""images"""', 'path'], {}), "('images', path)\n", (9602, 9618), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((9703, 9738), 'flask.send_from_directory', 'send_from_directory', (['"""audios"""', 'path'], {}), "('audios', path)\n", (9722, 9738), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((9809, 9834), 'flask.request.args.get', 'request.args.get', (['"""topic"""'], {}), "('topic')\n", (9825, 9834), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((10332, 10501), 'flask.jsonify', 'jsonify', (["{'title': title, 'story': story, 'id': tl, 'img': request.root_url +\n 'images/' + title + '.png', 'audio': request.root_url + 'audios/' +\n title + '.wav'}"], {}), "({'title': title, 'story': story, 'id': tl, 'img': request.root_url +\n 'images/' + title + '.png', 'audio': request.root_url + 'audios/' +\n title + '.wav'})\n", (10339, 10501), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((10857, 10882), 'flask.jsonify', 'jsonify', (["{'story': story}"], {}), "({'story': story})\n", (10864, 10882), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((11340, 11369), 'flask.jsonify', 'jsonify', (["{'stories': stories}"], {}), "({'stories': stories})\n", (11347, 11369), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((11673, 11701), 'flask.request.args.get', 'request.args.get', (['"""question"""'], {}), "('question')\n", (11689, 11701), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((11864, 11956), 'flask.jsonify', 'jsonify', (["{'response': response, 'audio': request.root_url + 'audios/' + 'temp' + '.wav'}"], {}), "({'response': response, 'audio': request.root_url + 'audios/' +\n 'temp' + '.wav'})\n", (11871, 11956), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((12075, 12096), 'google.cloud.speech.SpeechClient', 'speech.SpeechClient', ([], {}), '()\n', (12094, 12096), False, 'from google.cloud import speech\n'), ((12110, 12148), 'google.cloud.speech.RecognitionAudio', 'speech.RecognitionAudio', ([], {'content': 'audio'}), '(content=audio)\n', (12133, 12148), False, 'from google.cloud import speech\n'), ((12162, 12297), 'google.cloud.speech.RecognitionConfig', 'speech.RecognitionConfig', ([], {'encoding': 'speech.RecognitionConfig.AudioEncoding.LINEAR16', 'sample_rate_hertz': '(48000)', 'language_code': '"""en-US"""'}), "(encoding=speech.RecognitionConfig.AudioEncoding.\n LINEAR16, sample_rate_hertz=48000, language_code='en-US')\n", (12186, 12297), False, 'from google.cloud import speech\n'), ((13215, 13246), 'flask.jsonify', 'jsonify', (["{'response': response}"], {}), "({'response': response})\n", (13222, 13246), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((10594, 10616), 'flask.request.args.get', 'request.args.get', (['"""id"""'], {}), "('id')\n", (10610, 10616), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((11577, 11607), 'flask.request.args.get', 'request.args.get', (['"""session_id"""'], {}), "('session_id')\n", (11593, 11607), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((11628, 11656), 'flask.request.args.get', 'request.args.get', (['"""story_id"""'], {}), "('story_id')\n", (11644, 11656), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((13064, 13141), 'flask.jsonify', 'jsonify', (["{'response': 'Sorry, I could not understand you. Please try again.'}"], {}), "({'response': 'Sorry, I could not understand you. Please try again.'})\n", (13071, 13141), False, 'from flask import Flask, jsonify, request, json, send_from_directory\n'), ((5386, 5410), 'base64.b64decode', 'base64.b64decode', (['img[i]'], {}), '(img[i])\n', (5402, 5410), False, 'import base64\n')] |
from __future__ import annotations
import json
import logging
import boto3
import embeddings
import lancedb
from config import settings
# TODO: why doesn't logger print anything?
logger = logging.getLogger(__name__)
logging.getLogger().setLevel(logging.INFO)
client = boto3.client('cloudformation', region_name='us-east-1')
response = client.describe_stacks(
StackName=f'wb-agrifoods-data-lab-{settings.STAGE}'.lower(),
)
outputs = response['Stacks'][0]['Outputs']
[bucket_name] = [o['OutputValue'] for o in outputs if o['OutputKey'] == 'bucketname']
db = lancedb.connect(f's3://{bucket_name}/{settings.LANCEDB_DATA_PATH}')
with open('records_v1.0.json', 'r') as f:
records = json.loads(f.read())
# Flatten records
data = [
{'vector': r['embedding'], **{k: v for k, v in r.items() if k != 'embedding'}}
for r in records
]
# LanceDB assumes uses the keys from the first list element
# as the table columns, so we first ensure that all records
# have the set same of keys (values will be None for keys
# not relevant to a record)
key_set = set()
for d in data:
key_set.update(set(d.keys()))
data = [{**{k: None for k in key_set}, **d} for d in data]
print(len(data))
# Note: AWS S3 Buckets are not region specific, so the region
# doesn't really matter here
db.create_table('agrifood', data, mode='overwrite')
table = db.open_table('agrifood')
logger.info(table.head())
queries = [
'How is food security affected by drought in north africa?',
'How has climate change affected wheat production in asian minor in the past decade?',
'In what regions of the world is pivot irrigation most common?',
]
query_vectors = [
embeddings.client.embeddings.create(input=q, model=settings.OPENAI_EMBEDDING_MODEL)
.data[0]
.embedding
for q in queries
]
for q, v in zip(queries, query_vectors):
_type = 'project'
query_result = table.search(v).metric('cosine').where(f"type='{_type}'").limit(5)
print(f'QUERY: {q}')
print(f'RESULT: {query_result.to_list()}')
print('\n')
| [
"lancedb.connect"
] | [((191, 218), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (208, 218), False, 'import logging\n'), ((272, 327), 'boto3.client', 'boto3.client', (['"""cloudformation"""'], {'region_name': '"""us-east-1"""'}), "('cloudformation', region_name='us-east-1')\n", (284, 327), False, 'import boto3\n'), ((567, 634), 'lancedb.connect', 'lancedb.connect', (['f"""s3://{bucket_name}/{settings.LANCEDB_DATA_PATH}"""'], {}), "(f's3://{bucket_name}/{settings.LANCEDB_DATA_PATH}')\n", (582, 634), False, 'import lancedb\n'), ((219, 238), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (236, 238), False, 'import logging\n'), ((1664, 1752), 'embeddings.client.embeddings.create', 'embeddings.client.embeddings.create', ([], {'input': 'q', 'model': 'settings.OPENAI_EMBEDDING_MODEL'}), '(input=q, model=settings.\n OPENAI_EMBEDDING_MODEL)\n', (1699, 1752), False, 'import embeddings\n')] |
from typing import List, Union, Dict
from pathlib import Path
from enum import StrEnum
import lancedb
import numpy as np
from image_search.config.log_factory import logger
from image_search.model.image_data import ImageData
from image_search.model.error import Error, ErrorCode
from image_search.vector_db.imagedb_schema import schema
from image_search.model.image_data import convert_to_pyarrow
from image_search.config.config import cfg
from image_search.vector_db.imagedb_schema import (
FIELD_IMAGE_VECTOR,
FIELD_IMAGE_NAME,
FIELD_TEXT_VECTOR,
FIELD_IMAGE_DESCRIPTION,
FIELD_CREATE_TIMESTAMP,
FIELD_UPDATE_TIMESTAMP,
)
from image_search.service.conversion_service import (
convert_single_image,
)
class DISTANCE(StrEnum):
EUCLIDEAN = "l2"
COSINE = "cosine"
DOT = "dot"
def execute_knn_search(
embedding: List[float],
vector_column_name: str,
limit: int = 10,
distance: str = DISTANCE.EUCLIDEAN,
) -> List[Dict]:
return (
tbl.search(
embedding, query_type="vector", vector_column_name=vector_column_name
)
.metric(distance)
.limit(limit)
.to_list()
)
def init_image_vector_table() -> lancedb.table.LanceTable:
db = lancedb.connect(cfg.lance_db_location)
table_name = cfg.lance_table_image
try:
return db.open_table(table_name)
except FileNotFoundError as e:
logger.warning("Could not open database. It does not exist.")
return db.create_table(table_name, schema=schema)
tbl = init_image_vector_table()
def sql_escape(text: str) -> str:
return text.replace("'", "''")
def convert_vec_to_literal(float_list: List[float]) -> List[str]:
return [str(v) for v in float_list]
def save_image(image_data: ImageData, ignore_update: bool = False) -> bool:
results = execute_knn_search(image_data.image_embedding, FIELD_IMAGE_VECTOR, 1)
image_available = False
if len(results) > 0:
first_result = results[0]
image_available = np.array_equal(
first_result[FIELD_IMAGE_VECTOR], image_data.image_embedding
)
if not image_available: # insert
logger.info("Creating %s", image_data.file_name)
pa_table = convert_to_pyarrow(image_data, None)
tbl.add(pa_table)
return True
else: # update
logger.info("Updating %s", image_data.file_name)
first_result = results[0]
if ignore_update == False:
create_timestamp = first_result[FIELD_CREATE_TIMESTAMP]
pa_table = convert_to_pyarrow(image_data, create_timestamp)
single_value = {
FIELD_TEXT_VECTOR: convert_vec_to_literal(
first_result[FIELD_TEXT_VECTOR]
),
FIELD_IMAGE_DESCRIPTION: sql_escape(
first_result[FIELD_IMAGE_DESCRIPTION]
),
FIELD_IMAGE_VECTOR: convert_vec_to_literal(
first_result[FIELD_IMAGE_VECTOR]
),
FIELD_UPDATE_TIMESTAMP: first_result[FIELD_UPDATE_TIMESTAMP],
}
filter_expression = (
f"{FIELD_IMAGE_NAME} = '{first_result[FIELD_IMAGE_NAME]}'"
)
if image_data.image_path:
image_data.image_path.unlink()
tbl.update(where=filter_expression, values=single_value)
return False
async def save_image_from_path(image_path: Path) -> Union[bool, Error]:
if not image_path.exists():
return Error(
code=ErrorCode.NOT_FOUND,
message=f"Could not find original image path: {image_path}",
)
image_data = await convert_single_image(image_path)
if image_data is None:
return Error(
ErrorCode.DESCRIPTION_MISSING,
f"Image description is missing for {image_path}",
)
return save_image(image_data)
| [
"lancedb.connect"
] | [((1246, 1284), 'lancedb.connect', 'lancedb.connect', (['cfg.lance_db_location'], {}), '(cfg.lance_db_location)\n', (1261, 1284), False, 'import lancedb\n'), ((2025, 2101), 'numpy.array_equal', 'np.array_equal', (['first_result[FIELD_IMAGE_VECTOR]', 'image_data.image_embedding'], {}), '(first_result[FIELD_IMAGE_VECTOR], image_data.image_embedding)\n', (2039, 2101), True, 'import numpy as np\n'), ((2170, 2218), 'image_search.config.log_factory.logger.info', 'logger.info', (['"""Creating %s"""', 'image_data.file_name'], {}), "('Creating %s', image_data.file_name)\n", (2181, 2218), False, 'from image_search.config.log_factory import logger\n'), ((2238, 2274), 'image_search.model.image_data.convert_to_pyarrow', 'convert_to_pyarrow', (['image_data', 'None'], {}), '(image_data, None)\n', (2256, 2274), False, 'from image_search.model.image_data import convert_to_pyarrow\n'), ((2349, 2397), 'image_search.config.log_factory.logger.info', 'logger.info', (['"""Updating %s"""', 'image_data.file_name'], {}), "('Updating %s', image_data.file_name)\n", (2360, 2397), False, 'from image_search.config.log_factory import logger\n'), ((3540, 3637), 'image_search.model.error.Error', 'Error', ([], {'code': 'ErrorCode.NOT_FOUND', 'message': 'f"""Could not find original image path: {image_path}"""'}), "(code=ErrorCode.NOT_FOUND, message=\n f'Could not find original image path: {image_path}')\n", (3545, 3637), False, 'from image_search.model.error import Error, ErrorCode\n'), ((3691, 3723), 'image_search.service.conversion_service.convert_single_image', 'convert_single_image', (['image_path'], {}), '(image_path)\n', (3711, 3723), False, 'from image_search.service.conversion_service import convert_single_image\n'), ((3766, 3856), 'image_search.model.error.Error', 'Error', (['ErrorCode.DESCRIPTION_MISSING', 'f"""Image description is missing for {image_path}"""'], {}), "(ErrorCode.DESCRIPTION_MISSING,\n f'Image description is missing for {image_path}')\n", (3771, 3856), False, 'from image_search.model.error import Error, ErrorCode\n'), ((1417, 1478), 'image_search.config.log_factory.logger.warning', 'logger.warning', (['"""Could not open database. It does not exist."""'], {}), "('Could not open database. It does not exist.')\n", (1431, 1478), False, 'from image_search.config.log_factory import logger\n'), ((2558, 2606), 'image_search.model.image_data.convert_to_pyarrow', 'convert_to_pyarrow', (['image_data', 'create_timestamp'], {}), '(image_data, create_timestamp)\n', (2576, 2606), False, 'from image_search.model.image_data import convert_to_pyarrow\n')] |
import lancedb
import pyarrow as pa
uri = "data/sample-lancedb"
db = lancedb.connect(uri)
schema = pa.schema(
[
pa.field("vector", pa.list_(pa.float32(), 1536)),
pa.field("review", pa.string()),
pa.field("id",pa.string())
])
tbl = db.create_table("review_table", schema=schema)
print(tbl) | [
"lancedb.connect"
] | [((69, 89), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (84, 89), False, 'import lancedb\n'), ((195, 206), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (204, 206), True, 'import pyarrow as pa\n'), ((229, 240), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (238, 240), True, 'import pyarrow as pa\n'), ((148, 160), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (158, 160), True, 'import pyarrow as pa\n')] |
"""The lambda function for the Bolt app."""
import json
import logging
import os
import re
import time
from typing import Any
import lancedb
import slack_bolt
from langchain.chains.conversational_retrieval.base import ConversationalRetrievalChain
from langchain.memory.buffer import ConversationBufferMemory
from langchain_community.chat_message_histories import DynamoDBChatMessageHistory
from langchain_community.chat_models import ChatOpenAI
from langchain_community.vectorstores.lancedb import LanceDB
from langchain_core.callbacks.base import BaseCallbackHandler
from langchain_core.outputs.llm_result import LLMResult
from langchain_openai.embeddings import OpenAIEmbeddings
from slack_bolt import Ack, BoltContext, Say
from slack_bolt.adapter.aws_lambda import SlackRequestHandler
from slack_sdk.models.blocks import (
ContextBlock,
DividerBlock,
MarkdownTextObject,
SectionBlock,
)
INITIAL_CHAT_UPDATE_INTERVAL_SEC = 1
SlackRequestHandler.clear_all_log_handlers()
logging.basicConfig(
format="%(levelname)s %(message)s",
level=logging.INFO,
)
logger = logging.getLogger(__name__)
def initialize_conversation_memory(id_ts: str) -> ConversationBufferMemory:
"""Initialize the conversation memory.
Parameters
----------
id_ts: str
The ID timestamp.
Returns
-------
ConversationBufferMemory
The initialized conversation memory.
"""
history = DynamoDBChatMessageHistory(
table_name=os.environ["CHAT_HISTORY_TABLE"],
session_id=id_ts,
)
return ConversationBufferMemory(
chat_memory=history,
memory_key="chat_history",
return_messages=True,
)
def initialize_vector_store() -> LanceDB:
"""Initialize the vector store.
Returns
-------
LanceDB
The initialized vector store.
"""
db = lancedb.connect(os.environ["LANCEDB_DB"])
table = db.open_table(os.environ["LANCEDB_TABLE"])
embeddings = OpenAIEmbeddings()
return LanceDB(
table,
embeddings,
)
app = slack_bolt.App(
signing_secret=os.environ["SLACK_SIGNING_SECRET"],
token=os.environ["SLACK_BOT_TOKEN"],
process_before_response=True,
)
class SlackStreamingCallbackHandler(BaseCallbackHandler):
"""Handles callbacks for Slack streaming."""
last_send_time = time.time()
message = ""
def __init__(self: "SlackStreamingCallbackHandler", channel: str, ts: str) -> None:
"""Initialize the SlackStreamingCallbackHandler.
Parameters
----------
channel : str
The channel to send updates to.
ts : str
The timestamp of the message to update.
Returns
-------
None
This is a constructor method and does not return anything.
"""
self.channel = channel
self.ts = ts
self.interval = INITIAL_CHAT_UPDATE_INTERVAL_SEC
self.update_count = 0
def on_llm_new_token(
self: "SlackStreamingCallbackHandler",
token: str,
**kwargs: Any, # noqa: ARG002
) -> None:
"""Handle the new token received during the LLM process.
Parameters
----------
token : str
The new token received.
kwargs : Any
Additional keyword arguments.
Returns
-------
None
Nothing to return.
"""
self.message += token
now = time.time()
if now - self.last_send_time > self.interval:
app.client.chat_update(
channel=self.channel,
ts=self.ts,
text=f"{self.message}\n\nTyping...",
)
self.last_send_time = now
self.update_count += 1
if self.update_count / 10 > self.interval:
self.interval = self.interval * 2
def on_llm_end(
self: "SlackStreamingCallbackHandler",
response: LLMResult, # noqa: ARG002
**kwargs: Any, # noqa: ARG002
) -> None:
"""Handle the end of the LLM process.
This method is called when the LLM process is completed.
Parameters
----------
response : LLMResult
The response of the LLM process.
kwargs : Any
Additional keyword arguments.
Returns
-------
None
This method does not return anything.
"""
message_context = f"Generated by {os.environ['OPENAI_API_MODEL']}"
message_blocks = [
SectionBlock(text=MarkdownTextObject(text=self.message)),
DividerBlock(),
ContextBlock(elements=[MarkdownTextObject(text=message_context)]),
]
app.client.chat_update(
channel=self.channel,
ts=self.ts,
text=self.message,
blocks=message_blocks,
)
def handle_mention(event: dict, say: Say) -> None:
"""Handle the mention event.
Parameters
----------
event : dict
The mention event.
say : Say
The say function.
Returns
-------
None
This function does not return anything.
"""
channel = event["channel"]
thread_ts = event["ts"]
message = re.sub(r"<@.*>", "", event["text"]).strip()
id_ts = event["ts"]
if "thread_ts" in event:
id_ts = event["thread_ts"]
result = say("\n\nTyping...", thread_ts=thread_ts)
ts = result["ts"]
memory = initialize_conversation_memory(id_ts)
vector_store = initialize_vector_store()
slack_callback = SlackStreamingCallbackHandler(channel, ts)
llm = ChatOpenAI(
model=os.environ["OPENAI_API_MODEL"],
temperature=float(os.environ["OPENAI_API_TEMPERATURE"]),
streaming=True,
callbacks=[slack_callback],
)
condense_question_llm = ChatOpenAI(
model=os.environ["OPENAI_API_MODEL"],
temperature=float(os.environ["OPENAI_API_TEMPERATURE"]),
)
cr_chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=vector_store.as_retriever(),
memory=memory,
condense_question_llm=condense_question_llm,
)
cr_chain.run(message)
def just_ack(ack: Ack) -> None:
"""Just acknowledge the request.
Parameters
----------
ack : Ack
The acknowledgement function.
Returns
-------
None
This function does not return anything.
"""
ack()
app.event("app_mintion")(
ack=just_ack,
lazy=[handle_mention],
)
def lambda_handler(event: dict, context: BoltContext) -> dict:
"""Handle the Lambda function.
Parameters
----------
event : dict
The event dictionary.
context : BoltContext
The Bolt context.
Returns
-------
dict
The response dictionary.
"""
headers = event["headers"]
logger.info(json.dumps(headers))
if "x-slack-retry-num" in headers:
logger.info("SKIP > %s", headers["x-slack-retry-num"])
return {"statusCode": 200, "body": json.dumps({"message": "ok"})}
slack_handler = SlackRequestHandler(app=app)
return slack_handler.handle(event, context)
| [
"lancedb.connect"
] | [((946, 990), 'slack_bolt.adapter.aws_lambda.SlackRequestHandler.clear_all_log_handlers', 'SlackRequestHandler.clear_all_log_handlers', ([], {}), '()\n', (988, 990), False, 'from slack_bolt.adapter.aws_lambda import SlackRequestHandler\n'), ((991, 1066), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(levelname)s %(message)s"""', 'level': 'logging.INFO'}), "(format='%(levelname)s %(message)s', level=logging.INFO)\n", (1010, 1066), False, 'import logging\n'), ((1087, 1114), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1104, 1114), False, 'import logging\n'), ((2053, 2190), 'slack_bolt.App', 'slack_bolt.App', ([], {'signing_secret': "os.environ['SLACK_SIGNING_SECRET']", 'token': "os.environ['SLACK_BOT_TOKEN']", 'process_before_response': '(True)'}), "(signing_secret=os.environ['SLACK_SIGNING_SECRET'], token=os.\n environ['SLACK_BOT_TOKEN'], process_before_response=True)\n", (2067, 2190), False, 'import slack_bolt\n'), ((1429, 1522), 'langchain_community.chat_message_histories.DynamoDBChatMessageHistory', 'DynamoDBChatMessageHistory', ([], {'table_name': "os.environ['CHAT_HISTORY_TABLE']", 'session_id': 'id_ts'}), "(table_name=os.environ['CHAT_HISTORY_TABLE'],\n session_id=id_ts)\n", (1455, 1522), False, 'from langchain_community.chat_message_histories import DynamoDBChatMessageHistory\n'), ((1553, 1651), 'langchain.memory.buffer.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'chat_memory': 'history', 'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(chat_memory=history, memory_key='chat_history',\n return_messages=True)\n", (1577, 1651), False, 'from langchain.memory.buffer import ConversationBufferMemory\n'), ((1851, 1892), 'lancedb.connect', 'lancedb.connect', (["os.environ['LANCEDB_DB']"], {}), "(os.environ['LANCEDB_DB'])\n", (1866, 1892), False, 'import lancedb\n'), ((1965, 1983), 'langchain_openai.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (1981, 1983), False, 'from langchain_openai.embeddings import OpenAIEmbeddings\n'), ((1995, 2021), 'langchain_community.vectorstores.lancedb.LanceDB', 'LanceDB', (['table', 'embeddings'], {}), '(table, embeddings)\n', (2002, 2021), False, 'from langchain_community.vectorstores.lancedb import LanceDB\n'), ((2332, 2343), 'time.time', 'time.time', ([], {}), '()\n', (2341, 2343), False, 'import time\n'), ((7110, 7138), 'slack_bolt.adapter.aws_lambda.SlackRequestHandler', 'SlackRequestHandler', ([], {'app': 'app'}), '(app=app)\n', (7129, 7138), False, 'from slack_bolt.adapter.aws_lambda import SlackRequestHandler\n'), ((3454, 3465), 'time.time', 'time.time', ([], {}), '()\n', (3463, 3465), False, 'import time\n'), ((6891, 6910), 'json.dumps', 'json.dumps', (['headers'], {}), '(headers)\n', (6901, 6910), False, 'import json\n'), ((4615, 4629), 'slack_sdk.models.blocks.DividerBlock', 'DividerBlock', ([], {}), '()\n', (4627, 4629), False, 'from slack_sdk.models.blocks import ContextBlock, DividerBlock, MarkdownTextObject, SectionBlock\n'), ((5251, 5285), 're.sub', 're.sub', (['"""<@.*>"""', '""""""', "event['text']"], {}), "('<@.*>', '', event['text'])\n", (5257, 5285), False, 'import re\n'), ((7058, 7087), 'json.dumps', 'json.dumps', (["{'message': 'ok'}"], {}), "({'message': 'ok'})\n", (7068, 7087), False, 'import json\n'), ((4563, 4600), 'slack_sdk.models.blocks.MarkdownTextObject', 'MarkdownTextObject', ([], {'text': 'self.message'}), '(text=self.message)\n', (4581, 4600), False, 'from slack_sdk.models.blocks import ContextBlock, DividerBlock, MarkdownTextObject, SectionBlock\n'), ((4666, 4706), 'slack_sdk.models.blocks.MarkdownTextObject', 'MarkdownTextObject', ([], {'text': 'message_context'}), '(text=message_context)\n', (4684, 4706), False, 'from slack_sdk.models.blocks import ContextBlock, DividerBlock, MarkdownTextObject, SectionBlock\n')] |
"""LanceDB vector store."""
import logging
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import (
DEFAULT_DOC_ID_KEY,
DEFAULT_TEXT_KEY,
legacy_metadata_dict_to_node,
metadata_dict_to_node,
node_to_metadata_dict,
)
_logger = logging.getLogger(__name__)
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.legacy_filters():
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""
The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
vector_column_name (str, optional): The vector column name in the table if different from default.
Defaults to "vector", in keeping with lancedb convention.
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
vector_column_name: str = "vector",
nprobes: int = 20,
refine_factor: Optional[int] = None,
text_key: str = DEFAULT_TEXT_KEY,
doc_id_key: str = DEFAULT_DOC_ID_KEY,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.vector_column_name = vector_column_name
self.nprobes = nprobes
self.text_key = text_key
self.doc_id_key = doc_id_key
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=False, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
"metadata": metadata,
}
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(
query=query.query_embedding,
vector_column_name=self.vector_column_name,
)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_pandas()
nodes = []
for _, item in results.iterrows():
try:
node = metadata_dict_to_node(item.metadata)
node.embedding = list(item[self.vector_column_name])
except Exception:
# deprecated legacy logic for backward compatibility
_logger.debug(
"Failed to parse Node metadata, fallback to legacy logic."
)
if "metadata" in item:
metadata, node_info, _relation = legacy_metadata_dict_to_node(
item.metadata, text_key=self.text_key
)
else:
metadata, node_info = {}, {}
node = TextNode(
text=item[self.text_key] or "",
id_=item.id,
metadata=metadata,
start_char_idx=node_info.get("start", None),
end_char_idx=node_info.get("end", None),
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(
node_id=item[self.doc_id_key]
),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((585, 612), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (602, 612), False, 'import logging\n'), ((3266, 3286), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (3281, 3286), False, 'import lancedb\n'), ((1349, 1378), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1355, 1378), True, 'import numpy as np\n'), ((3821, 3906), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(False)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=False, flat_metadata=self.flat_metadata\n )\n', (3842, 3906), False, 'from llama_index.vector_stores.utils import DEFAULT_DOC_ID_KEY, DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((1259, 1283), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1265, 1283), True, 'import numpy as np\n'), ((6094, 6130), 'llama_index.vector_stores.utils.metadata_dict_to_node', 'metadata_dict_to_node', (['item.metadata'], {}), '(item.metadata)\n', (6115, 6130), False, 'from llama_index.vector_stores.utils import DEFAULT_DOC_ID_KEY, DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((6519, 6586), 'llama_index.vector_stores.utils.legacy_metadata_dict_to_node', 'legacy_metadata_dict_to_node', (['item.metadata'], {'text_key': 'self.text_key'}), '(item.metadata, text_key=self.text_key)\n', (6547, 6586), False, 'from llama_index.vector_stores.utils import DEFAULT_DOC_ID_KEY, DEFAULT_TEXT_KEY, legacy_metadata_dict_to_node, metadata_dict_to_node, node_to_metadata_dict\n'), ((7072, 7118), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item[self.doc_id_key]'}), '(node_id=item[self.doc_id_key])\n', (7087, 7118), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.filters:
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text,
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2773, 2793), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2788, 2793), False, 'import lancedb\n'), ((1170, 1199), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1176, 1199), True, 'import numpy as np\n'), ((3205, 3284), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=True, flat_metadata=self.flat_metadata)\n', (3226, 3284), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((1080, 1104), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1086, 1104), True, 'import numpy as np\n'), ((5506, 5542), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5521, 5542), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
from dotenv import load_dotenv
from pathlib import Path
from typing import List
import lancedb
import pypdf
from gpt_pdf_bot.shared import embed_text
from gpt_pdf_bot.types import Chunk, Document, Page
load_dotenv()
class PdfIngestionPipeline:
def __init__(self, pdf_directory: str):
self.pdf_directory = Path(pdf_directory)
self.db = lancedb.connect(uri=".lancedb")
def run(self) -> None:
print(f"Running ingestion pipeline on {self.pdf_directory}", end="\n\n")
documents = self.read_pdfs()
print(f"Read {len(documents)} documents", end="\n\n")
print("Splitting documents into chunks", end="\n\n")
chunks = self.chunk_documents(documents=documents)
print("Creating and persisting embeddings", end="\n\n")
table = self.create_and_persist_embeddings(chunks=chunks)
def read_pdfs(self) -> List[Document]:
documents = []
for pdf in self.pdf_directory.glob("*.pdf"):
print(f"Reading {pdf.name}")
reader = pypdf.PdfReader(pdf)
doc = Document(
source=pdf.name,
metadata=reader.metadata,
)
for i, page in enumerate(reader.pages):
doc.pages.append(
Page(
page_num=i,
text=page.extract_text(),
)
)
documents.append(doc)
return documents
def chunk_documents(
self,
documents: List[Document],
chunk_size: int = 1000,
chunk_overlap: int = 200,
) -> List[Chunk]:
# TODO: This is a naive implementation that is not smart about splitting on word boundaries
chunks = []
for doc in documents:
for page in doc.pages:
for i in range(0, len(page.text), chunk_size - chunk_overlap):
chunks.append(
Chunk(
text=page.text[i : i + chunk_size],
metadata={"source": doc.source, "page_num": page.page_num},
)
)
return chunks
def create_and_persist_embeddings(self, chunks: List[Chunk]):
# check if table exists
# TODO: this is a naive way to not recompute embeddings for the same pdfs
if self.pdf_directory.name in self.db.table_names():
return self.db[self.pdf_directory.name]
texts = [chunk.text for chunk in chunks]
embeddings = embed_text(texts=texts)
merged = []
for chunk, emb in zip(chunks, embeddings):
merged.append(
{
"text": chunk.text,
"metadata": chunk.metadata,
"vector": emb,
}
)
table = self.db.create_table(self.pdf_directory.name, data=merged)
print(f"Wrote {len(embeddings)} embeddings to {table.name} table")
return table
| [
"lancedb.connect"
] | [((204, 217), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (215, 217), False, 'from dotenv import load_dotenv\n'), ((321, 340), 'pathlib.Path', 'Path', (['pdf_directory'], {}), '(pdf_directory)\n', (325, 340), False, 'from pathlib import Path\n'), ((359, 390), 'lancedb.connect', 'lancedb.connect', ([], {'uri': '""".lancedb"""'}), "(uri='.lancedb')\n", (374, 390), False, 'import lancedb\n'), ((2552, 2575), 'gpt_pdf_bot.shared.embed_text', 'embed_text', ([], {'texts': 'texts'}), '(texts=texts)\n', (2562, 2575), False, 'from gpt_pdf_bot.shared import embed_text\n'), ((1034, 1054), 'pypdf.PdfReader', 'pypdf.PdfReader', (['pdf'], {}), '(pdf)\n', (1049, 1054), False, 'import pypdf\n'), ((1073, 1124), 'gpt_pdf_bot.types.Document', 'Document', ([], {'source': 'pdf.name', 'metadata': 'reader.metadata'}), '(source=pdf.name, metadata=reader.metadata)\n', (1081, 1124), False, 'from gpt_pdf_bot.types import Chunk, Document, Page\n'), ((1958, 2061), 'gpt_pdf_bot.types.Chunk', 'Chunk', ([], {'text': 'page.text[i:i + chunk_size]', 'metadata': "{'source': doc.source, 'page_num': page.page_num}"}), "(text=page.text[i:i + chunk_size], metadata={'source': doc.source,\n 'page_num': page.page_num})\n", (1963, 2061), False, 'from gpt_pdf_bot.types import Chunk, Document, Page\n')] |
import streamlit as st
import pandas as pd
import json
import requests
from datetime import datetime
from pathlib import Path
import lancedb
from services.lancedb_index import IndexDocuments
from services.lancedb_notes import IndexDocumentsNotes
import yaml
### For multipage note taking, save to a json and then load the json in a state
### Delete the file
### Create second page for using notes and searching those
### ### Sends it to a notes embedding api and index
### Create setup page to add templates, research buckets, etc
### ### Store initially as json, then as sqlite
### Create a drag and drop file upload with schema to add data
### ### Low priority
### Create a page where selected results are sent to a model for summaries for review/notes/etc
### ### Tag with the query, datetime, maybe a name from a modal pop out?
### Create a notes template
st.set_page_config(layout='wide',
page_title='Search')
notes_folder = Path('data/notes')
collections_folder = Path('data/collections')
tmp_folder = Path('data/tmp')
st.title("Welcome to streamSearchable\n**Your local reSearch engine**")
st.header("Query your data here:")
index_folder = Path('indexes')
index = lancedb.connect(index_folder)
available_indexes = index.table_names()
index_to_search = st.selectbox(label='Available Indexes', options=available_indexes)
query = st.text_input(label="What do you want to search?", value='')
result_cutoff = st.number_input(label='Result cutoff', value=50)
keyword_importance = st.slider(label='Importance of keyword matches',
min_value=0.0, max_value=1.0, step=0.05, value=0.5)
st.session_state['query'] = query
@st.cache_data
def remote_search(query, collection_name):
results = requests.post('http://localhost:8000/hybrid',
json={'query':query, 'collection_name':collection_name,
'top_k':50, 'fts_weight':keyword_importance, 'vec_weight':1-keyword_importance})
result_data, available_fields = results.json()
available_fields = set(available_fields)
new_fields = set()
for result in result_data:
if 'metadata' in result and len(result['metadata']) > 0:
metadata = json.loads(result['metadata'])
result.update(metadata)
new_fields.update(metadata.keys())
del result['metadata']
return result_data, sorted(list(new_fields))
if 'results_to_save' not in st.session_state:
st.session_state['results_to_save'] = dict()
def add_result_to_save(result):
note_hash = hash(str(result))
st.write(st.session_state['results_to_save'].keys())
if note_hash not in st.session_state['results_to_save']:
st.session_state['results_to_save'][note_hash] = result
else:
del st.session_state['results_to_save'][note_hash]
with st.sidebar:
current_collections = index.table_names()
selected_collections = st.selectbox('Existing Collection Destination',
options=current_collections)
new_index = st.text_input(label='Create new index', value='')
note_quick_view = [x['title'] for _hash, x in st.session_state['results_to_save'].items()]
st.markdown("Selected Notes")
st.json(note_quick_view, expanded=False)
if st.button('Save selected results'):
if new_index != '':
notes_save_name = new_index
else:
notes_save_name = selected_collections
notes_save_name = notes_save_name + '_notes'
notes_save_path = collections_folder.joinpath(notes_save_name)
notes_save_path.mkdir(parents=True, exist_ok=True)
notes_save_file = notes_save_path.joinpath('notes.json')
save_data = list()
for session_key, _note in st.session_state['results_to_save'].items():
save_data.append(_note)
with open(notes_save_file, 'w') as f:
json.dump(save_data, f)
indexer = IndexDocumentsNotes(field_mapping={'text':'text', 'tags':'tags','title':'title','date':'date'},
source_file=notes_save_file,
index_name=notes_save_name,
overwrite=False)
indexer.open_json()
indexer.create_documents()
indexer.ingest()
st.write('done')
if query:
query_results, available_fields = remote_search(query, index_to_search)
show_fields = st.multiselect("Show Fields", available_fields, default=available_fields)
st.write(len(query_results))
for index, result in enumerate(query_results):
st.markdown(f"**:blue[{result['title']}]**")
st.markdown(f"*:blue[Score: {round(result['score'], 3)}]*")
with st.container():
st.write(f"{' '.join(result['text'].split(' ')[:100])}.....")
with st.expander('See Full Text and Details'):
full_text, quick_annotate = st.columns([4,1])
with full_text:
if 'date' in result:
st.markdown(f"""**Date:** {result['date']}""")
if 'tags' in result:
st.markdown(f"""**Tags:** {', '.join(result['tags'])}""")
st.markdown('**Text:**')
st.markdown(result['text'])
for _field in show_fields:
st.markdown(f"**{_field}:** {result[_field]}")
save_to_collection = st.toggle('Save to collection',key=f'toggle_{index}',
on_change=add_result_to_save, args=(result, ))
st.divider()
| [
"lancedb.connect"
] | [((864, 918), 'streamlit.set_page_config', 'st.set_page_config', ([], {'layout': '"""wide"""', 'page_title': '"""Search"""'}), "(layout='wide', page_title='Search')\n", (882, 918), True, 'import streamlit as st\n'), ((953, 971), 'pathlib.Path', 'Path', (['"""data/notes"""'], {}), "('data/notes')\n", (957, 971), False, 'from pathlib import Path\n'), ((993, 1017), 'pathlib.Path', 'Path', (['"""data/collections"""'], {}), "('data/collections')\n", (997, 1017), False, 'from pathlib import Path\n'), ((1031, 1047), 'pathlib.Path', 'Path', (['"""data/tmp"""'], {}), "('data/tmp')\n", (1035, 1047), False, 'from pathlib import Path\n'), ((1049, 1123), 'streamlit.title', 'st.title', (['"""Welcome to streamSearchable\n**Your local reSearch engine**"""'], {}), '("""Welcome to streamSearchable\n**Your local reSearch engine**""")\n', (1057, 1123), True, 'import streamlit as st\n'), ((1123, 1157), 'streamlit.header', 'st.header', (['"""Query your data here:"""'], {}), "('Query your data here:')\n", (1132, 1157), True, 'import streamlit as st\n'), ((1173, 1188), 'pathlib.Path', 'Path', (['"""indexes"""'], {}), "('indexes')\n", (1177, 1188), False, 'from pathlib import Path\n'), ((1198, 1227), 'lancedb.connect', 'lancedb.connect', (['index_folder'], {}), '(index_folder)\n', (1213, 1227), False, 'import lancedb\n'), ((1286, 1352), 'streamlit.selectbox', 'st.selectbox', ([], {'label': '"""Available Indexes"""', 'options': 'available_indexes'}), "(label='Available Indexes', options=available_indexes)\n", (1298, 1352), True, 'import streamlit as st\n'), ((1362, 1422), 'streamlit.text_input', 'st.text_input', ([], {'label': '"""What do you want to search?"""', 'value': '""""""'}), "(label='What do you want to search?', value='')\n", (1375, 1422), True, 'import streamlit as st\n'), ((1439, 1487), 'streamlit.number_input', 'st.number_input', ([], {'label': '"""Result cutoff"""', 'value': '(50)'}), "(label='Result cutoff', value=50)\n", (1454, 1487), True, 'import streamlit as st\n'), ((1509, 1614), 'streamlit.slider', 'st.slider', ([], {'label': '"""Importance of keyword matches"""', 'min_value': '(0.0)', 'max_value': '(1.0)', 'step': '(0.05)', 'value': '(0.5)'}), "(label='Importance of keyword matches', min_value=0.0, max_value=\n 1.0, step=0.05, value=0.5)\n", (1518, 1614), True, 'import streamlit as st\n'), ((1748, 1945), 'requests.post', 'requests.post', (['"""http://localhost:8000/hybrid"""'], {'json': "{'query': query, 'collection_name': collection_name, 'top_k': 50,\n 'fts_weight': keyword_importance, 'vec_weight': 1 - keyword_importance}"}), "('http://localhost:8000/hybrid', json={'query': query,\n 'collection_name': collection_name, 'top_k': 50, 'fts_weight':\n keyword_importance, 'vec_weight': 1 - keyword_importance})\n", (1761, 1945), False, 'import requests\n'), ((2933, 3009), 'streamlit.selectbox', 'st.selectbox', (['"""Existing Collection Destination"""'], {'options': 'current_collections'}), "('Existing Collection Destination', options=current_collections)\n", (2945, 3009), True, 'import streamlit as st\n'), ((3065, 3114), 'streamlit.text_input', 'st.text_input', ([], {'label': '"""Create new index"""', 'value': '""""""'}), "(label='Create new index', value='')\n", (3078, 3114), True, 'import streamlit as st\n'), ((3215, 3244), 'streamlit.markdown', 'st.markdown', (['"""Selected Notes"""'], {}), "('Selected Notes')\n", (3226, 3244), True, 'import streamlit as st\n'), ((3249, 3289), 'streamlit.json', 'st.json', (['note_quick_view'], {'expanded': '(False)'}), '(note_quick_view, expanded=False)\n', (3256, 3289), True, 'import streamlit as st\n'), ((3297, 3331), 'streamlit.button', 'st.button', (['"""Save selected results"""'], {}), "('Save selected results')\n", (3306, 3331), True, 'import streamlit as st\n'), ((4444, 4517), 'streamlit.multiselect', 'st.multiselect', (['"""Show Fields"""', 'available_fields'], {'default': 'available_fields'}), "('Show Fields', available_fields, default=available_fields)\n", (4458, 4517), True, 'import streamlit as st\n'), ((3957, 4141), 'services.lancedb_notes.IndexDocumentsNotes', 'IndexDocumentsNotes', ([], {'field_mapping': "{'text': 'text', 'tags': 'tags', 'title': 'title', 'date': 'date'}", 'source_file': 'notes_save_file', 'index_name': 'notes_save_name', 'overwrite': '(False)'}), "(field_mapping={'text': 'text', 'tags': 'tags', 'title':\n 'title', 'date': 'date'}, source_file=notes_save_file, index_name=\n notes_save_name, overwrite=False)\n", (3976, 4141), False, 'from services.lancedb_notes import IndexDocumentsNotes\n'), ((4322, 4338), 'streamlit.write', 'st.write', (['"""done"""'], {}), "('done')\n", (4330, 4338), True, 'import streamlit as st\n'), ((4610, 4654), 'streamlit.markdown', 'st.markdown', (['f"""**:blue[{result[\'title\']}]**"""'], {}), '(f"**:blue[{result[\'title\']}]**")\n', (4621, 4654), True, 'import streamlit as st\n'), ((5610, 5622), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (5620, 5622), True, 'import streamlit as st\n'), ((2230, 2260), 'json.loads', 'json.loads', (["result['metadata']"], {}), "(result['metadata'])\n", (2240, 2260), False, 'import json\n'), ((3914, 3937), 'json.dump', 'json.dump', (['save_data', 'f'], {}), '(save_data, f)\n', (3923, 3937), False, 'import json\n'), ((4736, 4750), 'streamlit.container', 'st.container', ([], {}), '()\n', (4748, 4750), True, 'import streamlit as st\n'), ((5458, 5563), 'streamlit.toggle', 'st.toggle', (['"""Save to collection"""'], {'key': 'f"""toggle_{index}"""', 'on_change': 'add_result_to_save', 'args': '(result,)'}), "('Save to collection', key=f'toggle_{index}', on_change=\n add_result_to_save, args=(result,))\n", (5467, 5563), True, 'import streamlit as st\n'), ((4843, 4883), 'streamlit.expander', 'st.expander', (['"""See Full Text and Details"""'], {}), "('See Full Text and Details')\n", (4854, 4883), True, 'import streamlit as st\n'), ((4929, 4947), 'streamlit.columns', 'st.columns', (['[4, 1]'], {}), '([4, 1])\n', (4939, 4947), True, 'import streamlit as st\n'), ((5234, 5258), 'streamlit.markdown', 'st.markdown', (['"""**Text:**"""'], {}), "('**Text:**')\n", (5245, 5258), True, 'import streamlit as st\n'), ((5279, 5306), 'streamlit.markdown', 'st.markdown', (["result['text']"], {}), "(result['text'])\n", (5290, 5306), True, 'import streamlit as st\n'), ((5044, 5086), 'streamlit.markdown', 'st.markdown', (['f"""**Date:** {result[\'date\']}"""'], {}), '(f"**Date:** {result[\'date\']}")\n', (5055, 5086), True, 'import streamlit as st\n'), ((5378, 5424), 'streamlit.markdown', 'st.markdown', (['f"""**{_field}:** {result[_field]}"""'], {}), "(f'**{_field}:** {result[_field]}')\n", (5389, 5424), True, 'import streamlit as st\n')] |
"""
Unit test for retrieve_utils.py
"""
try:
import chromadb
from autogen.retrieve_utils import (
split_text_to_chunks,
extract_text_from_pdf,
split_files_to_chunks,
get_files_from_dir,
is_url,
create_vector_db_from_dir,
query_vector_db,
)
from autogen.token_count_utils import count_token
except ImportError:
skip = True
else:
skip = False
import os
import sys
import pytest
try:
from unstructured.partition.auto import partition
HAS_UNSTRUCTURED = True
except ImportError:
HAS_UNSTRUCTURED = False
test_dir = os.path.join(os.path.dirname(__file__), "test_files")
expected_text = """AutoGen is an advanced tool designed to assist developers in harnessing the capabilities
of Large Language Models (LLMs) for various applications. The primary purpose of AutoGen is to automate and
simplify the process of building applications that leverage the power of LLMs, allowing for seamless
integration, testing, and deployment."""
@pytest.mark.skipif(skip, reason="dependency is not installed")
class TestRetrieveUtils:
def test_split_text_to_chunks(self):
long_text = "A" * 10000
chunks = split_text_to_chunks(long_text, max_tokens=1000)
assert all(count_token(chunk) <= 1000 for chunk in chunks)
def test_split_text_to_chunks_raises_on_invalid_chunk_mode(self):
with pytest.raises(AssertionError):
split_text_to_chunks("A" * 10000, chunk_mode="bogus_chunk_mode")
def test_extract_text_from_pdf(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
assert "".join(expected_text.split()) == "".join(extract_text_from_pdf(pdf_file_path).strip().split())
def test_split_files_to_chunks(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path])
assert all(
isinstance(chunk, str) and "AutoGen is an advanced tool designed to assist developers" in chunk.strip()
for chunk in chunks
)
def test_get_files_from_dir(self):
files = get_files_from_dir(test_dir, recursive=False)
assert all(os.path.isfile(file) for file in files)
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
files = get_files_from_dir([pdf_file_path, txt_file_path])
assert all(os.path.isfile(file) for file in files)
files = get_files_from_dir(
[
pdf_file_path,
txt_file_path,
os.path.join(test_dir, "..", "..", "website/docs"),
"https://raw.githubusercontent.com/microsoft/autogen/main/README.md",
],
recursive=True,
)
assert all(os.path.isfile(file) for file in files)
files = get_files_from_dir(
[
pdf_file_path,
txt_file_path,
os.path.join(test_dir, "..", "..", "website/docs"),
"https://raw.githubusercontent.com/microsoft/autogen/main/README.md",
],
recursive=True,
types=["pdf", "txt"],
)
assert all(os.path.isfile(file) for file in files)
assert len(files) == 3
def test_is_url(self):
assert is_url("https://www.example.com")
assert not is_url("not_a_url")
def test_create_vector_db_from_dir(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else:
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
assert client.get_collection("all-my-documents")
def test_query_vector_db(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else: # If the database does not exist, create it first
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
results = query_vector_db(["autogen"], client=client)
assert isinstance(results, dict) and any("autogen" in res[0].lower() for res in results.get("documents", []))
def test_custom_vector_db(self):
try:
import lancedb
except ImportError:
return
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
db_path = "/tmp/lancedb"
def create_lancedb():
db = lancedb.connect(db_path)
data = [
{"vector": [1.1, 1.2], "id": 1, "documents": "This is a test document spark"},
{"vector": [0.2, 1.8], "id": 2, "documents": "This is another test document"},
{"vector": [0.1, 0.3], "id": 3, "documents": "This is a third test document spark"},
{"vector": [0.5, 0.7], "id": 4, "documents": "This is a fourth test document"},
{"vector": [2.1, 1.3], "id": 5, "documents": "This is a fifth test document spark"},
{"vector": [5.1, 8.3], "id": 6, "documents": "This is a sixth test document"},
]
try:
db.create_table("my_table", data)
except OSError:
pass
class MyRetrieveUserProxyAgent(RetrieveUserProxyAgent):
def query_vector_db(
self,
query_texts,
n_results=10,
search_string="",
):
if query_texts:
vector = [0.1, 0.3]
db = lancedb.connect(db_path)
table = db.open_table("my_table")
query = table.search(vector).where(f"documents LIKE '%{search_string}%'").limit(n_results).to_df()
return {"ids": [query["id"].tolist()], "documents": [query["documents"].tolist()]}
def retrieve_docs(self, problem: str, n_results: int = 20, search_string: str = ""):
results = self.query_vector_db(
query_texts=[problem],
n_results=n_results,
search_string=search_string,
)
self._results = results
print("doc_ids: ", results["ids"])
ragragproxyagent = MyRetrieveUserProxyAgent(
name="ragproxyagent",
human_input_mode="NEVER",
max_consecutive_auto_reply=2,
retrieve_config={
"task": "qa",
"chunk_token_size": 2000,
"client": "__",
"embedding_model": "all-mpnet-base-v2",
},
)
create_lancedb()
ragragproxyagent.retrieve_docs("This is a test document spark", n_results=10, search_string="spark")
assert ragragproxyagent._results["ids"] == [[3, 1, 5]]
def test_custom_text_split_function(self):
def custom_text_split_function(text):
return [text[: len(text) // 2], text[len(text) // 2 :]]
db_path = "/tmp/test_retrieve_utils_chromadb.db"
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(
os.path.join(test_dir, "example.txt"),
client=client,
collection_name="mytestcollection",
custom_text_split_function=custom_text_split_function,
get_or_create=True,
recursive=False,
)
results = query_vector_db(["autogen"], client=client, collection_name="mytestcollection", n_results=1)
assert (
"AutoGen is an advanced tool designed to assist developers in harnessing the capabilities"
in results.get("documents")[0][0]
)
def test_retrieve_utils(self):
client = chromadb.PersistentClient(path="/tmp/chromadb")
create_vector_db_from_dir(
dir_path="./website/docs",
client=client,
collection_name="autogen-docs",
custom_text_types=["txt", "md", "rtf", "rst"],
get_or_create=True,
)
results = query_vector_db(
query_texts=[
"How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?",
],
n_results=4,
client=client,
collection_name="autogen-docs",
search_string="AutoGen",
)
print(results["ids"][0])
assert len(results["ids"][0]) == 4
@pytest.mark.skipif(
not HAS_UNSTRUCTURED,
reason="do not run if unstructured is not installed",
)
def test_unstructured(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
word_file_path = os.path.join(test_dir, "example.docx")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path, word_file_path])
assert all(
isinstance(chunk, str) and "AutoGen is an advanced tool designed to assist developers" in chunk.strip()
for chunk in chunks
)
if __name__ == "__main__":
pytest.main()
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
os.remove(db_path) # Delete the database file after tests are finished
| [
"lancedb.connect"
] | [((1021, 1083), 'pytest.mark.skipif', 'pytest.mark.skipif', (['skip'], {'reason': '"""dependency is not installed"""'}), "(skip, reason='dependency is not installed')\n", (1039, 1083), False, 'import pytest\n'), ((619, 644), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (634, 644), False, 'import os\n'), ((8695, 8794), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(not HAS_UNSTRUCTURED)'], {'reason': '"""do not run if unstructured is not installed"""'}), "(not HAS_UNSTRUCTURED, reason=\n 'do not run if unstructured is not installed')\n", (8713, 8794), False, 'import pytest\n'), ((9332, 9345), 'pytest.main', 'pytest.main', ([], {}), '()\n', (9343, 9345), False, 'import pytest\n'), ((9407, 9430), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (9421, 9430), False, 'import os\n'), ((1199, 1247), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (['long_text'], {'max_tokens': '(1000)'}), '(long_text, max_tokens=1000)\n', (1219, 1247), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1574, 1611), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1586, 1611), False, 'import os\n'), ((1790, 1827), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1802, 1827), False, 'import os\n'), ((1852, 1889), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1864, 1889), False, 'import os\n'), ((1907, 1960), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (1928, 1960), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2195, 2240), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['test_dir'], {'recursive': '(False)'}), '(test_dir, recursive=False)\n', (2213, 2240), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2324, 2361), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (2336, 2361), False, 'import os\n'), ((2386, 2423), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (2398, 2423), False, 'import os\n'), ((2440, 2490), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (2458, 2490), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3414, 3447), 'autogen.retrieve_utils.is_url', 'is_url', (['"""https://www.example.com"""'], {}), "('https://www.example.com')\n", (3420, 3447), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3602, 3625), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (3616, 3625), False, 'import os\n'), ((3989, 4012), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (4003, 4012), False, 'import os\n'), ((4283, 4326), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client'}), "(['autogen'], client=client)\n", (4298, 4326), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((7323, 7362), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (7348, 7362), False, 'import chromadb\n'), ((7680, 7777), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client', 'collection_name': '"""mytestcollection"""', 'n_results': '(1)'}), "(['autogen'], client=client, collection_name=\n 'mytestcollection', n_results=1)\n", (7695, 7777), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8002, 8049), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""/tmp/chromadb"""'}), "(path='/tmp/chromadb')\n", (8027, 8049), False, 'import chromadb\n'), ((8058, 8232), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', ([], {'dir_path': '"""./website/docs"""', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'custom_text_types': "['txt', 'md', 'rtf', 'rst']", 'get_or_create': '(True)'}), "(dir_path='./website/docs', client=client,\n collection_name='autogen-docs', custom_text_types=['txt', 'md', 'rtf',\n 'rst'], get_or_create=True)\n", (8083, 8232), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8314, 8524), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', ([], {'query_texts': "['How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ]", 'n_results': '(4)', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'search_string': '"""AutoGen"""'}), "(query_texts=[\n 'How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ], n_results=4, client=client, collection_name='autogen-docs',\n search_string='AutoGen')\n", (8329, 8524), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8870, 8907), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (8882, 8907), False, 'import os\n'), ((8932, 8969), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (8944, 8969), False, 'import os\n'), ((8995, 9033), 'os.path.join', 'os.path.join', (['test_dir', '"""example.docx"""'], {}), "(test_dir, 'example.docx')\n", (9007, 9033), False, 'import os\n'), ((9051, 9120), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path, word_file_path]'], {}), '([pdf_file_path, txt_file_path, word_file_path])\n', (9072, 9120), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((9440, 9458), 'os.remove', 'os.remove', (['db_path'], {}), '(db_path)\n', (9449, 9458), False, 'import os\n'), ((1399, 1428), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1412, 1428), False, 'import pytest\n'), ((1442, 1506), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (["('A' * 10000)"], {'chunk_mode': '"""bogus_chunk_mode"""'}), "('A' * 10000, chunk_mode='bogus_chunk_mode')\n", (1462, 1506), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3467, 3486), 'autogen.retrieve_utils.is_url', 'is_url', (['"""not_a_url"""'], {}), "('not_a_url')\n", (3473, 3486), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3648, 3687), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (3673, 3687), False, 'import chromadb\n'), ((3723, 3762), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (3748, 3762), False, 'import chromadb\n'), ((3775, 3825), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (3800, 3825), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((4035, 4074), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (4060, 4074), False, 'import chromadb\n'), ((4161, 4200), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (4186, 4200), False, 'import chromadb\n'), ((4213, 4263), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (4238, 4263), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((4747, 4771), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (4762, 4771), False, 'import lancedb\n'), ((7410, 7447), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (7422, 7447), False, 'import os\n'), ((2260, 2280), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2274, 2280), False, 'import os\n'), ((2510, 2530), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2524, 2530), False, 'import os\n'), ((2678, 2728), 'os.path.join', 'os.path.join', (['test_dir', '""".."""', '""".."""', '"""website/docs"""'], {}), "(test_dir, '..', '..', 'website/docs')\n", (2690, 2728), False, 'import os\n'), ((2888, 2908), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2902, 2908), False, 'import os\n'), ((3056, 3106), 'os.path.join', 'os.path.join', (['test_dir', '""".."""', '""".."""', '"""website/docs"""'], {}), "(test_dir, '..', '..', 'website/docs')\n", (3068, 3106), False, 'import os\n'), ((3300, 3320), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (3314, 3320), False, 'import os\n'), ((5827, 5851), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (5842, 5851), False, 'import lancedb\n'), ((1267, 1285), 'autogen.token_count_utils.count_token', 'count_token', (['chunk'], {}), '(chunk)\n', (1278, 1285), False, 'from autogen.token_count_utils import count_token\n'), ((1669, 1705), 'autogen.retrieve_utils.extract_text_from_pdf', 'extract_text_from_pdf', (['pdf_file_path'], {}), '(pdf_file_path)\n', (1690, 1705), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n')] |
from langchain_community.vectorstores import LanceDB
from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
def test_lancedb() -> None:
import lancedb
embeddings = FakeEmbeddings()
db = lancedb.connect("/tmp/lancedb")
texts = ["text 1", "text 2", "item 3"]
vectors = embeddings.embed_documents(texts)
table = db.create_table(
"my_table",
data=[
{"vector": vectors[idx], "id": text, "text": text}
for idx, text in enumerate(texts)
],
mode="overwrite",
)
store = LanceDB(table, embeddings)
result = store.similarity_search("text 1")
result_texts = [doc.page_content for doc in result]
assert "text 1" in result_texts
def test_lancedb_add_texts() -> None:
import lancedb
embeddings = FakeEmbeddings()
db = lancedb.connect("/tmp/lancedb")
texts = ["text 1"]
vectors = embeddings.embed_documents(texts)
table = db.create_table(
"my_table",
data=[
{"vector": vectors[idx], "id": text, "text": text}
for idx, text in enumerate(texts)
],
mode="overwrite",
)
store = LanceDB(table, embeddings)
store.add_texts(["text 2"])
result = store.similarity_search("text 2")
result_texts = [doc.page_content for doc in result]
assert "text 2" in result_texts
| [
"lancedb.connect"
] | [((200, 216), 'tests.integration_tests.vectorstores.fake_embeddings.FakeEmbeddings', 'FakeEmbeddings', ([], {}), '()\n', (214, 216), False, 'from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings\n'), ((226, 257), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (241, 257), False, 'import lancedb\n'), ((577, 603), 'langchain_community.vectorstores.LanceDB', 'LanceDB', (['table', 'embeddings'], {}), '(table, embeddings)\n', (584, 603), False, 'from langchain_community.vectorstores import LanceDB\n'), ((820, 836), 'tests.integration_tests.vectorstores.fake_embeddings.FakeEmbeddings', 'FakeEmbeddings', ([], {}), '()\n', (834, 836), False, 'from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings\n'), ((846, 877), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (861, 877), False, 'import lancedb\n'), ((1177, 1203), 'langchain_community.vectorstores.LanceDB', 'LanceDB', (['table', 'embeddings'], {}), '(table, embeddings)\n', (1184, 1203), False, 'from langchain_community.vectorstores import LanceDB\n')] |
"""
Unit test for retrieve_utils.py
"""
from autogen.retrieve_utils import (
split_text_to_chunks,
extract_text_from_pdf,
split_files_to_chunks,
get_files_from_dir,
is_url,
create_vector_db_from_dir,
query_vector_db,
)
from autogen.token_count_utils import count_token
import os
import pytest
import chromadb
test_dir = os.path.join(os.path.dirname(__file__), "test_files")
expected_text = """AutoGen is an advanced tool designed to assist developers in harnessing the capabilities
of Large Language Models (LLMs) for various applications. The primary purpose of AutoGen is to automate and
simplify the process of building applications that leverage the power of LLMs, allowing for seamless
integration, testing, and deployment."""
class TestRetrieveUtils:
def test_split_text_to_chunks(self):
long_text = "A" * 10000
chunks = split_text_to_chunks(long_text, max_tokens=1000)
assert all(count_token(chunk) <= 1000 for chunk in chunks)
def test_split_text_to_chunks_raises_on_invalid_chunk_mode(self):
with pytest.raises(AssertionError):
split_text_to_chunks("A" * 10000, chunk_mode="bogus_chunk_mode")
def test_extract_text_from_pdf(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
assert "".join(expected_text.split()) == "".join(extract_text_from_pdf(pdf_file_path).strip().split())
def test_split_files_to_chunks(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path])
assert all(isinstance(chunk, str) and chunk.strip() for chunk in chunks)
def test_get_files_from_dir(self):
files = get_files_from_dir(test_dir)
assert all(os.path.isfile(file) for file in files)
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
files = get_files_from_dir([pdf_file_path, txt_file_path])
assert all(os.path.isfile(file) for file in files)
def test_is_url(self):
assert is_url("https://www.example.com")
assert not is_url("not_a_url")
def test_create_vector_db_from_dir(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else:
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
assert client.get_collection("all-my-documents")
def test_query_vector_db(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else: # If the database does not exist, create it first
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
results = query_vector_db(["autogen"], client=client)
assert isinstance(results, dict) and any("autogen" in res[0].lower() for res in results.get("documents", []))
def test_custom_vector_db(self):
try:
import lancedb
except ImportError:
return
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
db_path = "/tmp/lancedb"
def create_lancedb():
db = lancedb.connect(db_path)
data = [
{"vector": [1.1, 1.2], "id": 1, "documents": "This is a test document spark"},
{"vector": [0.2, 1.8], "id": 2, "documents": "This is another test document"},
{"vector": [0.1, 0.3], "id": 3, "documents": "This is a third test document spark"},
{"vector": [0.5, 0.7], "id": 4, "documents": "This is a fourth test document"},
{"vector": [2.1, 1.3], "id": 5, "documents": "This is a fifth test document spark"},
{"vector": [5.1, 8.3], "id": 6, "documents": "This is a sixth test document"},
]
try:
db.create_table("my_table", data)
except OSError:
pass
class MyRetrieveUserProxyAgent(RetrieveUserProxyAgent):
def query_vector_db(
self,
query_texts,
n_results=10,
search_string="",
):
if query_texts:
vector = [0.1, 0.3]
db = lancedb.connect(db_path)
table = db.open_table("my_table")
query = table.search(vector).where(f"documents LIKE '%{search_string}%'").limit(n_results).to_df()
return {"ids": [query["id"].tolist()], "documents": [query["documents"].tolist()]}
def retrieve_docs(self, problem: str, n_results: int = 20, search_string: str = ""):
results = self.query_vector_db(
query_texts=[problem],
n_results=n_results,
search_string=search_string,
)
self._results = results
print("doc_ids: ", results["ids"])
ragragproxyagent = MyRetrieveUserProxyAgent(
name="ragproxyagent",
human_input_mode="NEVER",
max_consecutive_auto_reply=2,
retrieve_config={
"task": "qa",
"chunk_token_size": 2000,
"client": "__",
"embedding_model": "all-mpnet-base-v2",
},
)
create_lancedb()
ragragproxyagent.retrieve_docs("This is a test document spark", n_results=10, search_string="spark")
assert ragragproxyagent._results["ids"] == [[3, 1, 5]]
def test_custom_text_split_function(self):
def custom_text_split_function(text):
return [text[: len(text) // 2], text[len(text) // 2 :]]
db_path = "/tmp/test_retrieve_utils_chromadb.db"
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(
os.path.join(test_dir, "example.txt"),
client=client,
collection_name="mytestcollection",
custom_text_split_function=custom_text_split_function,
get_or_create=True,
)
results = query_vector_db(["autogen"], client=client, collection_name="mytestcollection", n_results=1)
assert (
results.get("documents")[0][0]
== "AutoGen is an advanced tool designed to assist developers in harnessing the capabilities\nof Large Language Models (LLMs) for various applications. The primary purpose o"
)
def test_retrieve_utils(self):
client = chromadb.PersistentClient(path="/tmp/chromadb")
create_vector_db_from_dir(dir_path="./website/docs", client=client, collection_name="autogen-docs")
results = query_vector_db(
query_texts=[
"How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?",
],
n_results=4,
client=client,
collection_name="autogen-docs",
search_string="AutoGen",
)
print(results["ids"][0])
assert len(results["ids"][0]) == 4
if __name__ == "__main__":
pytest.main()
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
os.remove(db_path) # Delete the database file after tests are finished
| [
"lancedb.connect"
] | [((365, 390), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (380, 390), False, 'import os\n'), ((7383, 7396), 'pytest.main', 'pytest.main', ([], {}), '()\n', (7394, 7396), False, 'import pytest\n'), ((7458, 7481), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (7472, 7481), False, 'import os\n'), ((881, 929), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (['long_text'], {'max_tokens': '(1000)'}), '(long_text, max_tokens=1000)\n', (901, 929), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1256, 1293), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1268, 1293), False, 'import os\n'), ((1472, 1509), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1484, 1509), False, 'import os\n'), ((1534, 1571), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1546, 1571), False, 'import os\n'), ((1589, 1642), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (1610, 1642), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1780, 1808), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['test_dir'], {}), '(test_dir)\n', (1798, 1808), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1892, 1929), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1904, 1929), False, 'import os\n'), ((1954, 1991), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1966, 1991), False, 'import os\n'), ((2008, 2058), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (2026, 2058), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2161, 2194), 'autogen.retrieve_utils.is_url', 'is_url', (['"""https://www.example.com"""'], {}), "('https://www.example.com')\n", (2167, 2194), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2349, 2372), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (2363, 2372), False, 'import os\n'), ((2736, 2759), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (2750, 2759), False, 'import os\n'), ((3030, 3073), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client'}), "(['autogen'], client=client)\n", (3045, 3073), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6070, 6109), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (6095, 6109), False, 'import chromadb\n'), ((6398, 6495), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client', 'collection_name': '"""mytestcollection"""', 'n_results': '(1)'}), "(['autogen'], client=client, collection_name=\n 'mytestcollection', n_results=1)\n", (6413, 6495), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6801, 6848), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""/tmp/chromadb"""'}), "(path='/tmp/chromadb')\n", (6826, 6848), False, 'import chromadb\n'), ((6857, 6960), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', ([], {'dir_path': '"""./website/docs"""', 'client': 'client', 'collection_name': '"""autogen-docs"""'}), "(dir_path='./website/docs', client=client,\n collection_name='autogen-docs')\n", (6882, 6960), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6975, 7185), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', ([], {'query_texts': "['How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ]", 'n_results': '(4)', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'search_string': '"""AutoGen"""'}), "(query_texts=[\n 'How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ], n_results=4, client=client, collection_name='autogen-docs',\n search_string='AutoGen')\n", (6990, 7185), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((7491, 7509), 'os.remove', 'os.remove', (['db_path'], {}), '(db_path)\n', (7500, 7509), False, 'import os\n'), ((1081, 1110), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1094, 1110), False, 'import pytest\n'), ((1124, 1188), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (["('A' * 10000)"], {'chunk_mode': '"""bogus_chunk_mode"""'}), "('A' * 10000, chunk_mode='bogus_chunk_mode')\n", (1144, 1188), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2214, 2233), 'autogen.retrieve_utils.is_url', 'is_url', (['"""not_a_url"""'], {}), "('not_a_url')\n", (2220, 2233), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2395, 2434), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2420, 2434), False, 'import chromadb\n'), ((2470, 2509), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2495, 2509), False, 'import chromadb\n'), ((2522, 2572), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (2547, 2572), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2782, 2821), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2807, 2821), False, 'import chromadb\n'), ((2908, 2947), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2933, 2947), False, 'import chromadb\n'), ((2960, 3010), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (2985, 3010), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3494, 3518), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (3509, 3518), False, 'import lancedb\n'), ((6157, 6194), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (6169, 6194), False, 'import os\n'), ((1828, 1848), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (1842, 1848), False, 'import os\n'), ((2078, 2098), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2092, 2098), False, 'import os\n'), ((4574, 4598), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (4589, 4598), False, 'import lancedb\n'), ((949, 967), 'autogen.token_count_utils.count_token', 'count_token', (['chunk'], {}), '(chunk)\n', (960, 967), False, 'from autogen.token_count_utils import count_token\n'), ((1351, 1387), 'autogen.retrieve_utils.extract_text_from_pdf', 'extract_text_from_pdf', (['pdf_file_path'], {}), '(pdf_file_path)\n', (1372, 1387), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n')] |
import lancedb
import numpy as np
import pandas as pd
import pyarrow as pa
def client_vector_db(vector_db_config: dict) -> lancedb.LanceDBConnection:
"""Connect to a lancedb instance"""
return lancedb.connect(**vector_db_config)
def initialize_vector_db_indices(
client_vector_db: lancedb.LanceDBConnection,
class_name: str,
embedding_dimension: int,
) -> bool:
"""Initialize the LanceDB table;
NOTE this pattern currently doesn't work and is due to a bug with lancedb
"""
schema = pa.schema(
[
("squad_id", pa.string()),
("title", pa.string()),
("context", pa.string()),
("embedding_service", pa.string()),
("model_name", pa.string()),
pa.field("vector", type=pa.list_(pa.float32(), list_size=embedding_dimension)),
]
)
client_vector_db.create_table(name=class_name, schema=schema, mode="create")
return True
def reset_vector_db(client_vector_db: lancedb.LanceDBConnection) -> bool:
"""Delete all tables from the database"""
for table_name in client_vector_db.table_names():
client_vector_db.drop_table(table_name)
return True
def data_objects(
ids: list[str],
titles: list[str],
text_contents: list[str],
embeddings: list[np.ndarray],
metadata: dict,
) -> list[dict]:
"""Create valid LanceDB objects"""
assert len(ids) == len(titles) == len(text_contents) == len(embeddings)
return [
dict(squad_id=id_, title=title, context=context, vector=embedding, **metadata)
for id_, title, context, embedding in zip(ids, titles, text_contents, embeddings)
]
def push_to_vector_db(
client_vector_db: lancedb.LanceDBConnection,
class_name: str,
data_objects: list[dict],
embedding_metric: str = "cosine",
) -> int:
"""Push dataframe of objects to LanceDB.
Return number of objects.
"""
df = pd.DataFrame.from_records(data_objects)
table = client_vector_db.create_table(name=class_name, data=df, mode="overwrite")
return table.to_pandas().shape[0]
| [
"lancedb.connect"
] | [((203, 238), 'lancedb.connect', 'lancedb.connect', ([], {}), '(**vector_db_config)\n', (218, 238), False, 'import lancedb\n'), ((1932, 1971), 'pandas.DataFrame.from_records', 'pd.DataFrame.from_records', (['data_objects'], {}), '(data_objects)\n', (1957, 1971), True, 'import pandas as pd\n'), ((568, 579), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (577, 579), True, 'import pyarrow as pa\n'), ((604, 615), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (613, 615), True, 'import pyarrow as pa\n'), ((642, 653), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (651, 653), True, 'import pyarrow as pa\n'), ((690, 701), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (699, 701), True, 'import pyarrow as pa\n'), ((731, 742), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (740, 742), True, 'import pyarrow as pa\n'), ((790, 802), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (800, 802), True, 'import pyarrow as pa\n')] |
import os, sqlite3, lancedb, tiktoken, bcrypt
from pinecone import Pinecone, ServerlessSpec
from enum import Enum
from langchain_community.vectorstores import LanceDB, Chroma
from langchain_community.vectorstores import Pinecone as LangPinecone
import streamlit as st
def SetHeader(page_title: str):
st.set_page_config(page_title=page_title, page_icon="https://indico.bnl.gov/event/19560/logo-410523303.png", layout="wide")
st.warning("This project is being continuously developed. Please write to [email protected] for any feedback.")
col_l, col1, col2, col_r = st.columns([1, 3, 3, 1])
with col1:
st.image("https://indico.bnl.gov/event/19560/logo-410523303.png")
with col2:
st.title("""AI4EIC - RAG QA-ChatBot""", anchor = "AI4EIC-RAG-QA-Bot", help = "Will Link to arxiv proceeding here.")
class UserNotFoundError(Exception):
pass
class DBNotFoundError(Exception):
pass
def hash_password(password: str):
bytes = password.encode('utf-8')
salt = bcrypt.gensalt()
return bcrypt.hashpw(bytes, salt)
def get_user_info(db_name, username):
if not os.path.exists(db_name):
raise FileNotFoundError(f"Database {db_name} does not exist.")
conn = sqlite3.connect(db_name)
cursor = conn.cursor()
cursor.execute('''
SELECT username, first_name, last_name, password FROM users WHERE username = ?
''', (username,))
user = cursor.fetchone()
conn.close()
if user:
return user
else:
return None
def SetOpenAIModel(model_name: str):
if model_name == "4":
return False
class VectorDB(Enum):
LANCE = 1
CHROMA = 2
PINECONE = 3
def GetRetriever(TYPE: str, vector_config: dict, search_config = {}):
if TYPE == VectorDB.LANCE.name:
db = lancedb.connect(vector_config["db_name"])
table = db.open_table(vector_config["table_name"])
return LanceDB(connection = table,
embedding = vector_config["embedding_function"]
).as_retriever(search_type = search_config.get("metric", "similarity"),
search_kwargs=search_config.get("search_kwargs", {"k" : 100})
)
elif TYPE == VectorDB.CHROMA.name:
return Chroma(persist_directory = vector_config["db_name"],
embedding_function = vector_config["embedding_function"],
collection_name=vector_config["collection_name"]
).as_retriever(search_type = search_config.get("metric", "similarity"),
search_kwargs=search_config.get("search_kwargs", {"k" : 100})
)
elif TYPE == VectorDB.PINECONE.name:
pc = Pinecone(api_key = vector_config["db_api_key"])
if vector_config["index_name"] not in pc.list_indexes().names():
raise DBNotFoundError(f"Database {vector_config['index_name']} does not exist.")
return LangPinecone.from_existing_index(vector_config["index_name"],
vector_config["embedding_function"]
).as_retriever(search_type = search_config.get("metric", "similarity"),
search_kwargs=search_config.get("search_kwargs", {"k" : 100})
)
else:
raise NotImplementedError("Invalid VectorDB type")
def num_tokens_from_prompt(prompt: str, model: str) -> int:
"""Return the number of tokens used by a prompt."""
encoding = tiktoken.encoding_for_model(model)
return len(encoding.encode(prompt))
def num_tokens_from_messages(messages, model) -> int:
"""Return the number of tokens used by a list of messages."""
encoding = tiktoken.encoding_for_model(model)
tokens_per_message = 4 # every message follows <|start|>{role/name}\n{content}<|end|>\n
tokens_per_name = 1
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
for key, value in message.items():
num_tokens += len(encoding.encode(value))
if key == "name":
num_tokens += tokens_per_name
num_tokens += 4 # every reply is primed with <|start|>assistant<|message|>
return num_tokens | [
"lancedb.connect"
] | [((305, 433), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': 'page_title', 'page_icon': '"""https://indico.bnl.gov/event/19560/logo-410523303.png"""', 'layout': '"""wide"""'}), "(page_title=page_title, page_icon=\n 'https://indico.bnl.gov/event/19560/logo-410523303.png', layout='wide')\n", (323, 433), True, 'import streamlit as st\n'), ((433, 553), 'streamlit.warning', 'st.warning', (['"""This project is being continuously developed. Please write to [email protected] for any feedback."""'], {}), "(\n 'This project is being continuously developed. Please write to [email protected] for any feedback.'\n )\n", (443, 553), True, 'import streamlit as st\n'), ((575, 599), 'streamlit.columns', 'st.columns', (['[1, 3, 3, 1]'], {}), '([1, 3, 3, 1])\n', (585, 599), True, 'import streamlit as st\n'), ((1000, 1016), 'bcrypt.gensalt', 'bcrypt.gensalt', ([], {}), '()\n', (1014, 1016), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((1028, 1054), 'bcrypt.hashpw', 'bcrypt.hashpw', (['bytes', 'salt'], {}), '(bytes, salt)\n', (1041, 1054), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((1211, 1235), 'sqlite3.connect', 'sqlite3.connect', (['db_name'], {}), '(db_name)\n', (1226, 1235), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((3705, 3739), 'tiktoken.encoding_for_model', 'tiktoken.encoding_for_model', (['model'], {}), '(model)\n', (3732, 3739), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((3927, 3961), 'tiktoken.encoding_for_model', 'tiktoken.encoding_for_model', (['model'], {}), '(model)\n', (3954, 3961), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((623, 688), 'streamlit.image', 'st.image', (['"""https://indico.bnl.gov/event/19560/logo-410523303.png"""'], {}), "('https://indico.bnl.gov/event/19560/logo-410523303.png')\n", (631, 688), True, 'import streamlit as st\n'), ((712, 824), 'streamlit.title', 'st.title', (['"""AI4EIC - RAG QA-ChatBot"""'], {'anchor': '"""AI4EIC-RAG-QA-Bot"""', 'help': '"""Will Link to arxiv proceeding here."""'}), "('AI4EIC - RAG QA-ChatBot', anchor='AI4EIC-RAG-QA-Bot', help=\n 'Will Link to arxiv proceeding here.')\n", (720, 824), True, 'import streamlit as st\n'), ((1104, 1127), 'os.path.exists', 'os.path.exists', (['db_name'], {}), '(db_name)\n', (1118, 1127), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((1793, 1834), 'lancedb.connect', 'lancedb.connect', (["vector_config['db_name']"], {}), "(vector_config['db_name'])\n", (1808, 1834), False, 'import os, sqlite3, lancedb, tiktoken, bcrypt\n'), ((1909, 1981), 'langchain_community.vectorstores.LanceDB', 'LanceDB', ([], {'connection': 'table', 'embedding': "vector_config['embedding_function']"}), "(connection=table, embedding=vector_config['embedding_function'])\n", (1916, 1981), False, 'from langchain_community.vectorstores import LanceDB, Chroma\n'), ((2793, 2838), 'pinecone.Pinecone', 'Pinecone', ([], {'api_key': "vector_config['db_api_key']"}), "(api_key=vector_config['db_api_key'])\n", (2801, 2838), False, 'from pinecone import Pinecone, ServerlessSpec\n'), ((2300, 2466), 'langchain_community.vectorstores.Chroma', 'Chroma', ([], {'persist_directory': "vector_config['db_name']", 'embedding_function': "vector_config['embedding_function']", 'collection_name': "vector_config['collection_name']"}), "(persist_directory=vector_config['db_name'], embedding_function=\n vector_config['embedding_function'], collection_name=vector_config[\n 'collection_name'])\n", (2306, 2466), False, 'from langchain_community.vectorstores import LanceDB, Chroma\n'), ((3022, 3125), 'langchain_community.vectorstores.Pinecone.from_existing_index', 'LangPinecone.from_existing_index', (["vector_config['index_name']", "vector_config['embedding_function']"], {}), "(vector_config['index_name'], vector_config\n ['embedding_function'])\n", (3054, 3125), True, 'from langchain_community.vectorstores import Pinecone as LangPinecone\n')] |
from langchain import PromptTemplate, LLMChain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceBgeEmbeddings
from io import BytesIO
from langchain.document_loaders import PyPDFLoader
import gradio as gr
import lancedb
from langchain.vectorstores import LanceDB
from langchain.document_loaders import ArxivLoader
from langchain.chains import FlareChain
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import os
from langchain.llms import OpenAI
import getpass
os.environ["OPENAI_API_KEY"] = "sk-yourapikeyforopenai"
llm = OpenAI()
model_name = "BAAI/bge-large-en"
model_kwargs = {"device": "cpu"}
encode_kwargs = {"normalize_embeddings": False}
embeddings = HuggingFaceBgeEmbeddings(
model_name=model_name, model_kwargs=model_kwargs, encode_kwargs=encode_kwargs
)
# here is example https://arxiv.org/pdf/2305.06983.pdf
# you need to pass this number to query 2305.06983
# fetch docs from arxiv, in this case it's the FLARE paper
docs = ArxivLoader(query="2305.06983", load_max_docs=2).load()
# instantiate text splitter
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=150)
# split the document into chunks
doc_chunks = text_splitter.split_documents(docs)
# lancedb vectordb
db = lancedb.connect("/tmp/lancedb")
table = db.create_table(
"documentsai",
data=[
{
"vector": embeddings.embed_query("Hello World"),
"text": "Hello World",
"id": "1",
}
],
mode="overwrite",
)
vector_store = LanceDB.from_documents(doc_chunks, embeddings, connection=table)
vector_store_retriever = vector_store.as_retriever()
flare = FlareChain.from_llm(
llm=llm, retriever=vector_store_retriever, max_generation_len=300, min_prob=0.45
)
# Define a function to generate FLARE output based on user input
def generate_flare_output(input_text):
output = flare.run(input_text)
return output
input = gr.Text(
label="Prompt",
show_label=False,
max_lines=1,
placeholder="Enter your prompt",
container=False,
)
iface = gr.Interface(
fn=generate_flare_output,
inputs=input,
outputs="text",
title="My AI bot",
description="FLARE implementation with lancedb & bge embedding.",
)
iface.launch(debug=True, share=True)
| [
"lancedb.connect"
] | [((704, 712), 'langchain.llms.OpenAI', 'OpenAI', ([], {}), '()\n', (710, 712), False, 'from langchain.llms import OpenAI\n'), ((841, 948), 'langchain.embeddings.HuggingFaceBgeEmbeddings', 'HuggingFaceBgeEmbeddings', ([], {'model_name': 'model_name', 'model_kwargs': 'model_kwargs', 'encode_kwargs': 'encode_kwargs'}), '(model_name=model_name, model_kwargs=model_kwargs,\n encode_kwargs=encode_kwargs)\n', (865, 948), False, 'from langchain.embeddings import HuggingFaceBgeEmbeddings\n'), ((1225, 1291), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1500)', 'chunk_overlap': '(150)'}), '(chunk_size=1500, chunk_overlap=150)\n', (1255, 1291), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1400, 1431), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (1415, 1431), False, 'import lancedb\n'), ((1672, 1736), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['doc_chunks', 'embeddings'], {'connection': 'table'}), '(doc_chunks, embeddings, connection=table)\n', (1694, 1736), False, 'from langchain.vectorstores import LanceDB\n'), ((1800, 1905), 'langchain.chains.FlareChain.from_llm', 'FlareChain.from_llm', ([], {'llm': 'llm', 'retriever': 'vector_store_retriever', 'max_generation_len': '(300)', 'min_prob': '(0.45)'}), '(llm=llm, retriever=vector_store_retriever,\n max_generation_len=300, min_prob=0.45)\n', (1819, 1905), False, 'from langchain.chains import FlareChain\n'), ((2077, 2186), 'gradio.Text', 'gr.Text', ([], {'label': '"""Prompt"""', 'show_label': '(False)', 'max_lines': '(1)', 'placeholder': '"""Enter your prompt"""', 'container': '(False)'}), "(label='Prompt', show_label=False, max_lines=1, placeholder=\n 'Enter your prompt', container=False)\n", (2084, 2186), True, 'import gradio as gr\n'), ((2214, 2377), 'gradio.Interface', 'gr.Interface', ([], {'fn': 'generate_flare_output', 'inputs': 'input', 'outputs': '"""text"""', 'title': '"""My AI bot"""', 'description': '"""FLARE implementation with lancedb & bge embedding."""'}), "(fn=generate_flare_output, inputs=input, outputs='text', title=\n 'My AI bot', description=\n 'FLARE implementation with lancedb & bge embedding.')\n", (2226, 2377), True, 'import gradio as gr\n'), ((1124, 1172), 'langchain.document_loaders.ArxivLoader', 'ArxivLoader', ([], {'query': '"""2305.06983"""', 'load_max_docs': '(2)'}), "(query='2305.06983', load_max_docs=2)\n", (1135, 1172), False, 'from langchain.document_loaders import ArxivLoader\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
import numpy as np
from pandas import DataFrame
from llama_index.schema import (
BaseNode,
MetadataMode,
NodeRelationship,
RelatedNodeInfo,
TextNode,
)
from llama_index.vector_stores.types import (
MetadataFilters,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.filters:
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
def _to_llama_similarities(results: DataFrame) -> List[float]:
keys = results.keys()
normalized_similarities: np.ndarray
if "score" in keys:
normalized_similarities = np.exp(results["score"] - np.max(results["score"]))
elif "_distance" in keys:
normalized_similarities = np.exp(-results["_distance"])
else:
normalized_similarities = np.linspace(1, 0, len(results))
return normalized_similarities.tolist()
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return
def add(
self,
nodes: List[BaseNode],
**add_kwargs: Any,
) -> List[str]:
data = []
ids = []
for node in nodes:
metadata = node_to_metadata_dict(
node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": node.node_id,
"doc_id": node.ref_doc_id,
"vector": node.get_embedding(),
"text": node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(node.node_id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text,
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=_to_llama_similarities(results),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2773, 2793), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2788, 2793), False, 'import lancedb\n'), ((1170, 1199), 'numpy.exp', 'np.exp', (["(-results['_distance'])"], {}), "(-results['_distance'])\n", (1176, 1199), True, 'import numpy as np\n'), ((3205, 3284), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(node, remove_text=True, flat_metadata=self.flat_metadata)\n', (3226, 3284), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((1080, 1104), 'numpy.max', 'np.max', (["results['score']"], {}), "(results['score'])\n", (1086, 1104), True, 'import numpy as np\n'), ((5506, 5542), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5521, 5542), False, 'from llama_index.schema import BaseNode, MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |
"""
Unit test for retrieve_utils.py
"""
try:
import chromadb
from autogen.retrieve_utils import (
split_text_to_chunks,
extract_text_from_pdf,
split_files_to_chunks,
get_files_from_dir,
is_url,
create_vector_db_from_dir,
query_vector_db,
)
from autogen.token_count_utils import count_token
except ImportError:
skip = True
else:
skip = False
import os
import sys
import pytest
try:
from unstructured.partition.auto import partition
HAS_UNSTRUCTURED = True
except ImportError:
HAS_UNSTRUCTURED = False
test_dir = os.path.join(os.path.dirname(__file__), "test_files")
expected_text = """AutoGen is an advanced tool designed to assist developers in harnessing the capabilities
of Large Language Models (LLMs) for various applications. The primary purpose of AutoGen is to automate and
simplify the process of building applications that leverage the power of LLMs, allowing for seamless
integration, testing, and deployment."""
@pytest.mark.skipif(skip, reason="dependency is not installed")
class TestRetrieveUtils:
def test_split_text_to_chunks(self):
long_text = "A" * 10000
chunks = split_text_to_chunks(long_text, max_tokens=1000)
assert all(count_token(chunk) <= 1000 for chunk in chunks)
def test_split_text_to_chunks_raises_on_invalid_chunk_mode(self):
with pytest.raises(AssertionError):
split_text_to_chunks("A" * 10000, chunk_mode="bogus_chunk_mode")
def test_extract_text_from_pdf(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
assert "".join(expected_text.split()) == "".join(extract_text_from_pdf(pdf_file_path).strip().split())
def test_split_files_to_chunks(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path])
assert all(
isinstance(chunk, str) and "AutoGen is an advanced tool designed to assist developers" in chunk.strip()
for chunk in chunks
)
def test_get_files_from_dir(self):
files = get_files_from_dir(test_dir, recursive=False)
assert all(os.path.isfile(file) for file in files)
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
files = get_files_from_dir([pdf_file_path, txt_file_path])
assert all(os.path.isfile(file) for file in files)
files = get_files_from_dir(
[
pdf_file_path,
txt_file_path,
os.path.join(test_dir, "..", "..", "website/docs"),
"https://raw.githubusercontent.com/microsoft/autogen/main/README.md",
],
recursive=True,
)
assert all(os.path.isfile(file) for file in files)
files = get_files_from_dir(
[
pdf_file_path,
txt_file_path,
os.path.join(test_dir, "..", "..", "website/docs"),
"https://raw.githubusercontent.com/microsoft/autogen/main/README.md",
],
recursive=True,
types=["pdf", "txt"],
)
assert all(os.path.isfile(file) for file in files)
assert len(files) == 3
def test_is_url(self):
assert is_url("https://www.example.com")
assert not is_url("not_a_url")
def test_create_vector_db_from_dir(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else:
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
assert client.get_collection("all-my-documents")
def test_query_vector_db(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else: # If the database does not exist, create it first
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
results = query_vector_db(["autogen"], client=client)
assert isinstance(results, dict) and any("autogen" in res[0].lower() for res in results.get("documents", []))
def test_custom_vector_db(self):
try:
import lancedb
except ImportError:
return
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
db_path = "/tmp/lancedb"
def create_lancedb():
db = lancedb.connect(db_path)
data = [
{"vector": [1.1, 1.2], "id": 1, "documents": "This is a test document spark"},
{"vector": [0.2, 1.8], "id": 2, "documents": "This is another test document"},
{"vector": [0.1, 0.3], "id": 3, "documents": "This is a third test document spark"},
{"vector": [0.5, 0.7], "id": 4, "documents": "This is a fourth test document"},
{"vector": [2.1, 1.3], "id": 5, "documents": "This is a fifth test document spark"},
{"vector": [5.1, 8.3], "id": 6, "documents": "This is a sixth test document"},
]
try:
db.create_table("my_table", data)
except OSError:
pass
class MyRetrieveUserProxyAgent(RetrieveUserProxyAgent):
def query_vector_db(
self,
query_texts,
n_results=10,
search_string="",
):
if query_texts:
vector = [0.1, 0.3]
db = lancedb.connect(db_path)
table = db.open_table("my_table")
query = table.search(vector).where(f"documents LIKE '%{search_string}%'").limit(n_results).to_df()
return {"ids": [query["id"].tolist()], "documents": [query["documents"].tolist()]}
def retrieve_docs(self, problem: str, n_results: int = 20, search_string: str = ""):
results = self.query_vector_db(
query_texts=[problem],
n_results=n_results,
search_string=search_string,
)
self._results = results
print("doc_ids: ", results["ids"])
ragragproxyagent = MyRetrieveUserProxyAgent(
name="ragproxyagent",
human_input_mode="NEVER",
max_consecutive_auto_reply=2,
retrieve_config={
"task": "qa",
"chunk_token_size": 2000,
"client": "__",
"embedding_model": "all-mpnet-base-v2",
},
)
create_lancedb()
ragragproxyagent.retrieve_docs("This is a test document spark", n_results=10, search_string="spark")
assert ragragproxyagent._results["ids"] == [[3, 1, 5]]
def test_custom_text_split_function(self):
def custom_text_split_function(text):
return [text[: len(text) // 2], text[len(text) // 2 :]]
db_path = "/tmp/test_retrieve_utils_chromadb.db"
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(
os.path.join(test_dir, "example.txt"),
client=client,
collection_name="mytestcollection",
custom_text_split_function=custom_text_split_function,
get_or_create=True,
recursive=False,
)
results = query_vector_db(["autogen"], client=client, collection_name="mytestcollection", n_results=1)
assert (
"AutoGen is an advanced tool designed to assist developers in harnessing the capabilities"
in results.get("documents")[0][0]
)
def test_retrieve_utils(self):
client = chromadb.PersistentClient(path="/tmp/chromadb")
create_vector_db_from_dir(
dir_path="./website/docs",
client=client,
collection_name="autogen-docs",
custom_text_types=["txt", "md", "rtf", "rst"],
get_or_create=True,
)
results = query_vector_db(
query_texts=[
"How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?",
],
n_results=4,
client=client,
collection_name="autogen-docs",
search_string="AutoGen",
)
print(results["ids"][0])
assert len(results["ids"][0]) == 4
@pytest.mark.skipif(
not HAS_UNSTRUCTURED,
reason="do not run if unstructured is not installed",
)
def test_unstructured(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
word_file_path = os.path.join(test_dir, "example.docx")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path, word_file_path])
assert all(
isinstance(chunk, str) and "AutoGen is an advanced tool designed to assist developers" in chunk.strip()
for chunk in chunks
)
if __name__ == "__main__":
pytest.main()
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
os.remove(db_path) # Delete the database file after tests are finished
| [
"lancedb.connect"
] | [((1021, 1083), 'pytest.mark.skipif', 'pytest.mark.skipif', (['skip'], {'reason': '"""dependency is not installed"""'}), "(skip, reason='dependency is not installed')\n", (1039, 1083), False, 'import pytest\n'), ((619, 644), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (634, 644), False, 'import os\n'), ((8695, 8794), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(not HAS_UNSTRUCTURED)'], {'reason': '"""do not run if unstructured is not installed"""'}), "(not HAS_UNSTRUCTURED, reason=\n 'do not run if unstructured is not installed')\n", (8713, 8794), False, 'import pytest\n'), ((9332, 9345), 'pytest.main', 'pytest.main', ([], {}), '()\n', (9343, 9345), False, 'import pytest\n'), ((9407, 9430), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (9421, 9430), False, 'import os\n'), ((1199, 1247), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (['long_text'], {'max_tokens': '(1000)'}), '(long_text, max_tokens=1000)\n', (1219, 1247), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1574, 1611), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1586, 1611), False, 'import os\n'), ((1790, 1827), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1802, 1827), False, 'import os\n'), ((1852, 1889), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1864, 1889), False, 'import os\n'), ((1907, 1960), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (1928, 1960), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2195, 2240), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['test_dir'], {'recursive': '(False)'}), '(test_dir, recursive=False)\n', (2213, 2240), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2324, 2361), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (2336, 2361), False, 'import os\n'), ((2386, 2423), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (2398, 2423), False, 'import os\n'), ((2440, 2490), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (2458, 2490), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3414, 3447), 'autogen.retrieve_utils.is_url', 'is_url', (['"""https://www.example.com"""'], {}), "('https://www.example.com')\n", (3420, 3447), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3602, 3625), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (3616, 3625), False, 'import os\n'), ((3989, 4012), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (4003, 4012), False, 'import os\n'), ((4283, 4326), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client'}), "(['autogen'], client=client)\n", (4298, 4326), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((7323, 7362), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (7348, 7362), False, 'import chromadb\n'), ((7680, 7777), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client', 'collection_name': '"""mytestcollection"""', 'n_results': '(1)'}), "(['autogen'], client=client, collection_name=\n 'mytestcollection', n_results=1)\n", (7695, 7777), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8002, 8049), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""/tmp/chromadb"""'}), "(path='/tmp/chromadb')\n", (8027, 8049), False, 'import chromadb\n'), ((8058, 8232), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', ([], {'dir_path': '"""./website/docs"""', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'custom_text_types': "['txt', 'md', 'rtf', 'rst']", 'get_or_create': '(True)'}), "(dir_path='./website/docs', client=client,\n collection_name='autogen-docs', custom_text_types=['txt', 'md', 'rtf',\n 'rst'], get_or_create=True)\n", (8083, 8232), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8314, 8524), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', ([], {'query_texts': "['How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ]", 'n_results': '(4)', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'search_string': '"""AutoGen"""'}), "(query_texts=[\n 'How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ], n_results=4, client=client, collection_name='autogen-docs',\n search_string='AutoGen')\n", (8329, 8524), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8870, 8907), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (8882, 8907), False, 'import os\n'), ((8932, 8969), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (8944, 8969), False, 'import os\n'), ((8995, 9033), 'os.path.join', 'os.path.join', (['test_dir', '"""example.docx"""'], {}), "(test_dir, 'example.docx')\n", (9007, 9033), False, 'import os\n'), ((9051, 9120), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path, word_file_path]'], {}), '([pdf_file_path, txt_file_path, word_file_path])\n', (9072, 9120), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((9440, 9458), 'os.remove', 'os.remove', (['db_path'], {}), '(db_path)\n', (9449, 9458), False, 'import os\n'), ((1399, 1428), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1412, 1428), False, 'import pytest\n'), ((1442, 1506), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (["('A' * 10000)"], {'chunk_mode': '"""bogus_chunk_mode"""'}), "('A' * 10000, chunk_mode='bogus_chunk_mode')\n", (1462, 1506), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3467, 3486), 'autogen.retrieve_utils.is_url', 'is_url', (['"""not_a_url"""'], {}), "('not_a_url')\n", (3473, 3486), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3648, 3687), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (3673, 3687), False, 'import chromadb\n'), ((3723, 3762), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (3748, 3762), False, 'import chromadb\n'), ((3775, 3825), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (3800, 3825), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((4035, 4074), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (4060, 4074), False, 'import chromadb\n'), ((4161, 4200), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (4186, 4200), False, 'import chromadb\n'), ((4213, 4263), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (4238, 4263), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((4747, 4771), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (4762, 4771), False, 'import lancedb\n'), ((7410, 7447), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (7422, 7447), False, 'import os\n'), ((2260, 2280), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2274, 2280), False, 'import os\n'), ((2510, 2530), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2524, 2530), False, 'import os\n'), ((2678, 2728), 'os.path.join', 'os.path.join', (['test_dir', '""".."""', '""".."""', '"""website/docs"""'], {}), "(test_dir, '..', '..', 'website/docs')\n", (2690, 2728), False, 'import os\n'), ((2888, 2908), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2902, 2908), False, 'import os\n'), ((3056, 3106), 'os.path.join', 'os.path.join', (['test_dir', '""".."""', '""".."""', '"""website/docs"""'], {}), "(test_dir, '..', '..', 'website/docs')\n", (3068, 3106), False, 'import os\n'), ((3300, 3320), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (3314, 3320), False, 'import os\n'), ((5827, 5851), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (5842, 5851), False, 'import lancedb\n'), ((1267, 1285), 'autogen.token_count_utils.count_token', 'count_token', (['chunk'], {}), '(chunk)\n', (1278, 1285), False, 'from autogen.token_count_utils import count_token\n'), ((1669, 1705), 'autogen.retrieve_utils.extract_text_from_pdf', 'extract_text_from_pdf', (['pdf_file_path'], {}), '(pdf_file_path)\n', (1690, 1705), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n')] |
"""
Unit test for retrieve_utils.py
"""
try:
import chromadb
from autogen.retrieve_utils import (
split_text_to_chunks,
extract_text_from_pdf,
split_files_to_chunks,
get_files_from_dir,
is_url,
create_vector_db_from_dir,
query_vector_db,
)
from autogen.token_count_utils import count_token
except ImportError:
skip = True
else:
skip = False
import os
import sys
import pytest
try:
from unstructured.partition.auto import partition
HAS_UNSTRUCTURED = True
except ImportError:
HAS_UNSTRUCTURED = False
test_dir = os.path.join(os.path.dirname(__file__), "test_files")
expected_text = """AutoGen is an advanced tool designed to assist developers in harnessing the capabilities
of Large Language Models (LLMs) for various applications. The primary purpose of AutoGen is to automate and
simplify the process of building applications that leverage the power of LLMs, allowing for seamless
integration, testing, and deployment."""
@pytest.mark.skipif(skip, reason="dependency is not installed")
class TestRetrieveUtils:
def test_split_text_to_chunks(self):
long_text = "A" * 10000
chunks = split_text_to_chunks(long_text, max_tokens=1000)
assert all(count_token(chunk) <= 1000 for chunk in chunks)
def test_split_text_to_chunks_raises_on_invalid_chunk_mode(self):
with pytest.raises(AssertionError):
split_text_to_chunks("A" * 10000, chunk_mode="bogus_chunk_mode")
def test_extract_text_from_pdf(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
assert "".join(expected_text.split()) == "".join(extract_text_from_pdf(pdf_file_path).strip().split())
def test_split_files_to_chunks(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path])
assert all(
isinstance(chunk, str) and "AutoGen is an advanced tool designed to assist developers" in chunk.strip()
for chunk in chunks
)
def test_get_files_from_dir(self):
files = get_files_from_dir(test_dir, recursive=False)
assert all(os.path.isfile(file) for file in files)
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
files = get_files_from_dir([pdf_file_path, txt_file_path])
assert all(os.path.isfile(file) for file in files)
files = get_files_from_dir(
[
pdf_file_path,
txt_file_path,
os.path.join(test_dir, "..", "..", "website/docs"),
"https://raw.githubusercontent.com/microsoft/autogen/main/README.md",
],
recursive=True,
)
assert all(os.path.isfile(file) for file in files)
files = get_files_from_dir(
[
pdf_file_path,
txt_file_path,
os.path.join(test_dir, "..", "..", "website/docs"),
"https://raw.githubusercontent.com/microsoft/autogen/main/README.md",
],
recursive=True,
types=["pdf", "txt"],
)
assert all(os.path.isfile(file) for file in files)
assert len(files) == 3
def test_is_url(self):
assert is_url("https://www.example.com")
assert not is_url("not_a_url")
def test_create_vector_db_from_dir(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else:
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
assert client.get_collection("all-my-documents")
def test_query_vector_db(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else: # If the database does not exist, create it first
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
results = query_vector_db(["autogen"], client=client)
assert isinstance(results, dict) and any("autogen" in res[0].lower() for res in results.get("documents", []))
def test_custom_vector_db(self):
try:
import lancedb
except ImportError:
return
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
db_path = "/tmp/lancedb"
def create_lancedb():
db = lancedb.connect(db_path)
data = [
{"vector": [1.1, 1.2], "id": 1, "documents": "This is a test document spark"},
{"vector": [0.2, 1.8], "id": 2, "documents": "This is another test document"},
{"vector": [0.1, 0.3], "id": 3, "documents": "This is a third test document spark"},
{"vector": [0.5, 0.7], "id": 4, "documents": "This is a fourth test document"},
{"vector": [2.1, 1.3], "id": 5, "documents": "This is a fifth test document spark"},
{"vector": [5.1, 8.3], "id": 6, "documents": "This is a sixth test document"},
]
try:
db.create_table("my_table", data)
except OSError:
pass
class MyRetrieveUserProxyAgent(RetrieveUserProxyAgent):
def query_vector_db(
self,
query_texts,
n_results=10,
search_string="",
):
if query_texts:
vector = [0.1, 0.3]
db = lancedb.connect(db_path)
table = db.open_table("my_table")
query = table.search(vector).where(f"documents LIKE '%{search_string}%'").limit(n_results).to_df()
return {"ids": [query["id"].tolist()], "documents": [query["documents"].tolist()]}
def retrieve_docs(self, problem: str, n_results: int = 20, search_string: str = ""):
results = self.query_vector_db(
query_texts=[problem],
n_results=n_results,
search_string=search_string,
)
self._results = results
print("doc_ids: ", results["ids"])
ragragproxyagent = MyRetrieveUserProxyAgent(
name="ragproxyagent",
human_input_mode="NEVER",
max_consecutive_auto_reply=2,
retrieve_config={
"task": "qa",
"chunk_token_size": 2000,
"client": "__",
"embedding_model": "all-mpnet-base-v2",
},
)
create_lancedb()
ragragproxyagent.retrieve_docs("This is a test document spark", n_results=10, search_string="spark")
assert ragragproxyagent._results["ids"] == [[3, 1, 5]]
def test_custom_text_split_function(self):
def custom_text_split_function(text):
return [text[: len(text) // 2], text[len(text) // 2 :]]
db_path = "/tmp/test_retrieve_utils_chromadb.db"
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(
os.path.join(test_dir, "example.txt"),
client=client,
collection_name="mytestcollection",
custom_text_split_function=custom_text_split_function,
get_or_create=True,
recursive=False,
)
results = query_vector_db(["autogen"], client=client, collection_name="mytestcollection", n_results=1)
assert (
"AutoGen is an advanced tool designed to assist developers in harnessing the capabilities"
in results.get("documents")[0][0]
)
def test_retrieve_utils(self):
client = chromadb.PersistentClient(path="/tmp/chromadb")
create_vector_db_from_dir(
dir_path="./website/docs",
client=client,
collection_name="autogen-docs",
custom_text_types=["txt", "md", "rtf", "rst"],
get_or_create=True,
)
results = query_vector_db(
query_texts=[
"How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?",
],
n_results=4,
client=client,
collection_name="autogen-docs",
search_string="AutoGen",
)
print(results["ids"][0])
assert len(results["ids"][0]) == 4
@pytest.mark.skipif(
not HAS_UNSTRUCTURED,
reason="do not run if unstructured is not installed",
)
def test_unstructured(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
word_file_path = os.path.join(test_dir, "example.docx")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path, word_file_path])
assert all(
isinstance(chunk, str) and "AutoGen is an advanced tool designed to assist developers" in chunk.strip()
for chunk in chunks
)
if __name__ == "__main__":
pytest.main()
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
os.remove(db_path) # Delete the database file after tests are finished
| [
"lancedb.connect"
] | [((1021, 1083), 'pytest.mark.skipif', 'pytest.mark.skipif', (['skip'], {'reason': '"""dependency is not installed"""'}), "(skip, reason='dependency is not installed')\n", (1039, 1083), False, 'import pytest\n'), ((619, 644), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (634, 644), False, 'import os\n'), ((8695, 8794), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(not HAS_UNSTRUCTURED)'], {'reason': '"""do not run if unstructured is not installed"""'}), "(not HAS_UNSTRUCTURED, reason=\n 'do not run if unstructured is not installed')\n", (8713, 8794), False, 'import pytest\n'), ((9332, 9345), 'pytest.main', 'pytest.main', ([], {}), '()\n', (9343, 9345), False, 'import pytest\n'), ((9407, 9430), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (9421, 9430), False, 'import os\n'), ((1199, 1247), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (['long_text'], {'max_tokens': '(1000)'}), '(long_text, max_tokens=1000)\n', (1219, 1247), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1574, 1611), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1586, 1611), False, 'import os\n'), ((1790, 1827), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1802, 1827), False, 'import os\n'), ((1852, 1889), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1864, 1889), False, 'import os\n'), ((1907, 1960), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (1928, 1960), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2195, 2240), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['test_dir'], {'recursive': '(False)'}), '(test_dir, recursive=False)\n', (2213, 2240), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2324, 2361), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (2336, 2361), False, 'import os\n'), ((2386, 2423), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (2398, 2423), False, 'import os\n'), ((2440, 2490), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (2458, 2490), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3414, 3447), 'autogen.retrieve_utils.is_url', 'is_url', (['"""https://www.example.com"""'], {}), "('https://www.example.com')\n", (3420, 3447), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3602, 3625), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (3616, 3625), False, 'import os\n'), ((3989, 4012), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (4003, 4012), False, 'import os\n'), ((4283, 4326), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client'}), "(['autogen'], client=client)\n", (4298, 4326), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((7323, 7362), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (7348, 7362), False, 'import chromadb\n'), ((7680, 7777), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client', 'collection_name': '"""mytestcollection"""', 'n_results': '(1)'}), "(['autogen'], client=client, collection_name=\n 'mytestcollection', n_results=1)\n", (7695, 7777), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8002, 8049), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""/tmp/chromadb"""'}), "(path='/tmp/chromadb')\n", (8027, 8049), False, 'import chromadb\n'), ((8058, 8232), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', ([], {'dir_path': '"""./website/docs"""', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'custom_text_types': "['txt', 'md', 'rtf', 'rst']", 'get_or_create': '(True)'}), "(dir_path='./website/docs', client=client,\n collection_name='autogen-docs', custom_text_types=['txt', 'md', 'rtf',\n 'rst'], get_or_create=True)\n", (8083, 8232), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8314, 8524), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', ([], {'query_texts': "['How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ]", 'n_results': '(4)', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'search_string': '"""AutoGen"""'}), "(query_texts=[\n 'How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ], n_results=4, client=client, collection_name='autogen-docs',\n search_string='AutoGen')\n", (8329, 8524), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((8870, 8907), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (8882, 8907), False, 'import os\n'), ((8932, 8969), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (8944, 8969), False, 'import os\n'), ((8995, 9033), 'os.path.join', 'os.path.join', (['test_dir', '"""example.docx"""'], {}), "(test_dir, 'example.docx')\n", (9007, 9033), False, 'import os\n'), ((9051, 9120), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path, word_file_path]'], {}), '([pdf_file_path, txt_file_path, word_file_path])\n', (9072, 9120), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((9440, 9458), 'os.remove', 'os.remove', (['db_path'], {}), '(db_path)\n', (9449, 9458), False, 'import os\n'), ((1399, 1428), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1412, 1428), False, 'import pytest\n'), ((1442, 1506), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (["('A' * 10000)"], {'chunk_mode': '"""bogus_chunk_mode"""'}), "('A' * 10000, chunk_mode='bogus_chunk_mode')\n", (1462, 1506), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3467, 3486), 'autogen.retrieve_utils.is_url', 'is_url', (['"""not_a_url"""'], {}), "('not_a_url')\n", (3473, 3486), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3648, 3687), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (3673, 3687), False, 'import chromadb\n'), ((3723, 3762), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (3748, 3762), False, 'import chromadb\n'), ((3775, 3825), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (3800, 3825), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((4035, 4074), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (4060, 4074), False, 'import chromadb\n'), ((4161, 4200), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (4186, 4200), False, 'import chromadb\n'), ((4213, 4263), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (4238, 4263), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((4747, 4771), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (4762, 4771), False, 'import lancedb\n'), ((7410, 7447), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (7422, 7447), False, 'import os\n'), ((2260, 2280), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2274, 2280), False, 'import os\n'), ((2510, 2530), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2524, 2530), False, 'import os\n'), ((2678, 2728), 'os.path.join', 'os.path.join', (['test_dir', '""".."""', '""".."""', '"""website/docs"""'], {}), "(test_dir, '..', '..', 'website/docs')\n", (2690, 2728), False, 'import os\n'), ((2888, 2908), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2902, 2908), False, 'import os\n'), ((3056, 3106), 'os.path.join', 'os.path.join', (['test_dir', '""".."""', '""".."""', '"""website/docs"""'], {}), "(test_dir, '..', '..', 'website/docs')\n", (3068, 3106), False, 'import os\n'), ((3300, 3320), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (3314, 3320), False, 'import os\n'), ((5827, 5851), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (5842, 5851), False, 'import lancedb\n'), ((1267, 1285), 'autogen.token_count_utils.count_token', 'count_token', (['chunk'], {}), '(chunk)\n', (1278, 1285), False, 'from autogen.token_count_utils import count_token\n'), ((1669, 1705), 'autogen.retrieve_utils.extract_text_from_pdf', 'extract_text_from_pdf', (['pdf_file_path'], {}), '(pdf_file_path)\n', (1690, 1705), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n')] |
from langchain_community.vectorstores import LanceDB
from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
def test_lancedb() -> None:
import lancedb
embeddings = FakeEmbeddings()
db = lancedb.connect("/tmp/lancedb")
texts = ["text 1", "text 2", "item 3"]
vectors = embeddings.embed_documents(texts)
table = db.create_table(
"my_table",
data=[
{"vector": vectors[idx], "id": text, "text": text}
for idx, text in enumerate(texts)
],
mode="overwrite",
)
store = LanceDB(table, embeddings)
result = store.similarity_search("text 1")
result_texts = [doc.page_content for doc in result]
assert "text 1" in result_texts
def test_lancedb_add_texts() -> None:
import lancedb
embeddings = FakeEmbeddings()
db = lancedb.connect("/tmp/lancedb")
texts = ["text 1"]
vectors = embeddings.embed_documents(texts)
table = db.create_table(
"my_table",
data=[
{"vector": vectors[idx], "id": text, "text": text}
for idx, text in enumerate(texts)
],
mode="overwrite",
)
store = LanceDB(table, embeddings)
store.add_texts(["text 2"])
result = store.similarity_search("text 2")
result_texts = [doc.page_content for doc in result]
assert "text 2" in result_texts
| [
"lancedb.connect"
] | [((200, 216), 'tests.integration_tests.vectorstores.fake_embeddings.FakeEmbeddings', 'FakeEmbeddings', ([], {}), '()\n', (214, 216), False, 'from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings\n'), ((226, 257), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (241, 257), False, 'import lancedb\n'), ((577, 603), 'langchain_community.vectorstores.LanceDB', 'LanceDB', (['table', 'embeddings'], {}), '(table, embeddings)\n', (584, 603), False, 'from langchain_community.vectorstores import LanceDB\n'), ((820, 836), 'tests.integration_tests.vectorstores.fake_embeddings.FakeEmbeddings', 'FakeEmbeddings', ([], {}), '()\n', (834, 836), False, 'from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings\n'), ((846, 877), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (861, 877), False, 'import lancedb\n'), ((1177, 1203), 'langchain_community.vectorstores.LanceDB', 'LanceDB', (['table', 'embeddings'], {}), '(table, embeddings)\n', (1184, 1203), False, 'from langchain_community.vectorstores import LanceDB\n')] |
from langchain_community.vectorstores import LanceDB
from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
def test_lancedb() -> None:
import lancedb
embeddings = FakeEmbeddings()
db = lancedb.connect("/tmp/lancedb")
texts = ["text 1", "text 2", "item 3"]
vectors = embeddings.embed_documents(texts)
table = db.create_table(
"my_table",
data=[
{"vector": vectors[idx], "id": text, "text": text}
for idx, text in enumerate(texts)
],
mode="overwrite",
)
store = LanceDB(table, embeddings)
result = store.similarity_search("text 1")
result_texts = [doc.page_content for doc in result]
assert "text 1" in result_texts
def test_lancedb_add_texts() -> None:
import lancedb
embeddings = FakeEmbeddings()
db = lancedb.connect("/tmp/lancedb")
texts = ["text 1"]
vectors = embeddings.embed_documents(texts)
table = db.create_table(
"my_table",
data=[
{"vector": vectors[idx], "id": text, "text": text}
for idx, text in enumerate(texts)
],
mode="overwrite",
)
store = LanceDB(table, embeddings)
store.add_texts(["text 2"])
result = store.similarity_search("text 2")
result_texts = [doc.page_content for doc in result]
assert "text 2" in result_texts
| [
"lancedb.connect"
] | [((200, 216), 'tests.integration_tests.vectorstores.fake_embeddings.FakeEmbeddings', 'FakeEmbeddings', ([], {}), '()\n', (214, 216), False, 'from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings\n'), ((226, 257), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (241, 257), False, 'import lancedb\n'), ((577, 603), 'langchain_community.vectorstores.LanceDB', 'LanceDB', (['table', 'embeddings'], {}), '(table, embeddings)\n', (584, 603), False, 'from langchain_community.vectorstores import LanceDB\n'), ((820, 836), 'tests.integration_tests.vectorstores.fake_embeddings.FakeEmbeddings', 'FakeEmbeddings', ([], {}), '()\n', (834, 836), False, 'from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings\n'), ((846, 877), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (861, 877), False, 'import lancedb\n'), ((1177, 1203), 'langchain_community.vectorstores.LanceDB', 'LanceDB', (['table', 'embeddings'], {}), '(table, embeddings)\n', (1184, 1203), False, 'from langchain_community.vectorstores import LanceDB\n')] |
"""
Unit test for retrieve_utils.py
"""
from autogen.retrieve_utils import (
split_text_to_chunks,
extract_text_from_pdf,
split_files_to_chunks,
get_files_from_dir,
is_url,
create_vector_db_from_dir,
query_vector_db,
)
from autogen.token_count_utils import count_token
import os
import pytest
import chromadb
test_dir = os.path.join(os.path.dirname(__file__), "test_files")
expected_text = """AutoGen is an advanced tool designed to assist developers in harnessing the capabilities
of Large Language Models (LLMs) for various applications. The primary purpose of AutoGen is to automate and
simplify the process of building applications that leverage the power of LLMs, allowing for seamless
integration, testing, and deployment."""
class TestRetrieveUtils:
def test_split_text_to_chunks(self):
long_text = "A" * 10000
chunks = split_text_to_chunks(long_text, max_tokens=1000)
assert all(count_token(chunk) <= 1000 for chunk in chunks)
def test_split_text_to_chunks_raises_on_invalid_chunk_mode(self):
with pytest.raises(AssertionError):
split_text_to_chunks("A" * 10000, chunk_mode="bogus_chunk_mode")
def test_extract_text_from_pdf(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
assert "".join(expected_text.split()) == "".join(extract_text_from_pdf(pdf_file_path).strip().split())
def test_split_files_to_chunks(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path])
assert all(isinstance(chunk, str) and chunk.strip() for chunk in chunks)
def test_get_files_from_dir(self):
files = get_files_from_dir(test_dir)
assert all(os.path.isfile(file) for file in files)
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
files = get_files_from_dir([pdf_file_path, txt_file_path])
assert all(os.path.isfile(file) for file in files)
def test_is_url(self):
assert is_url("https://www.example.com")
assert not is_url("not_a_url")
def test_create_vector_db_from_dir(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else:
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
assert client.get_collection("all-my-documents")
def test_query_vector_db(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else: # If the database does not exist, create it first
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
results = query_vector_db(["autogen"], client=client)
assert isinstance(results, dict) and any("autogen" in res[0].lower() for res in results.get("documents", []))
def test_custom_vector_db(self):
try:
import lancedb
except ImportError:
return
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
db_path = "/tmp/lancedb"
def create_lancedb():
db = lancedb.connect(db_path)
data = [
{"vector": [1.1, 1.2], "id": 1, "documents": "This is a test document spark"},
{"vector": [0.2, 1.8], "id": 2, "documents": "This is another test document"},
{"vector": [0.1, 0.3], "id": 3, "documents": "This is a third test document spark"},
{"vector": [0.5, 0.7], "id": 4, "documents": "This is a fourth test document"},
{"vector": [2.1, 1.3], "id": 5, "documents": "This is a fifth test document spark"},
{"vector": [5.1, 8.3], "id": 6, "documents": "This is a sixth test document"},
]
try:
db.create_table("my_table", data)
except OSError:
pass
class MyRetrieveUserProxyAgent(RetrieveUserProxyAgent):
def query_vector_db(
self,
query_texts,
n_results=10,
search_string="",
):
if query_texts:
vector = [0.1, 0.3]
db = lancedb.connect(db_path)
table = db.open_table("my_table")
query = table.search(vector).where(f"documents LIKE '%{search_string}%'").limit(n_results).to_df()
return {"ids": [query["id"].tolist()], "documents": [query["documents"].tolist()]}
def retrieve_docs(self, problem: str, n_results: int = 20, search_string: str = ""):
results = self.query_vector_db(
query_texts=[problem],
n_results=n_results,
search_string=search_string,
)
self._results = results
print("doc_ids: ", results["ids"])
ragragproxyagent = MyRetrieveUserProxyAgent(
name="ragproxyagent",
human_input_mode="NEVER",
max_consecutive_auto_reply=2,
retrieve_config={
"task": "qa",
"chunk_token_size": 2000,
"client": "__",
"embedding_model": "all-mpnet-base-v2",
},
)
create_lancedb()
ragragproxyagent.retrieve_docs("This is a test document spark", n_results=10, search_string="spark")
assert ragragproxyagent._results["ids"] == [[3, 1, 5]]
def test_custom_text_split_function(self):
def custom_text_split_function(text):
return [text[: len(text) // 2], text[len(text) // 2 :]]
db_path = "/tmp/test_retrieve_utils_chromadb.db"
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(
os.path.join(test_dir, "example.txt"),
client=client,
collection_name="mytestcollection",
custom_text_split_function=custom_text_split_function,
get_or_create=True,
)
results = query_vector_db(["autogen"], client=client, collection_name="mytestcollection", n_results=1)
assert (
results.get("documents")[0][0]
== "AutoGen is an advanced tool designed to assist developers in harnessing the capabilities\nof Large Language Models (LLMs) for various applications. The primary purpose o"
)
def test_retrieve_utils(self):
client = chromadb.PersistentClient(path="/tmp/chromadb")
create_vector_db_from_dir(dir_path="./website/docs", client=client, collection_name="autogen-docs")
results = query_vector_db(
query_texts=[
"How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?",
],
n_results=4,
client=client,
collection_name="autogen-docs",
search_string="AutoGen",
)
print(results["ids"][0])
assert len(results["ids"][0]) == 4
if __name__ == "__main__":
pytest.main()
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
os.remove(db_path) # Delete the database file after tests are finished
| [
"lancedb.connect"
] | [((365, 390), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (380, 390), False, 'import os\n'), ((7383, 7396), 'pytest.main', 'pytest.main', ([], {}), '()\n', (7394, 7396), False, 'import pytest\n'), ((7458, 7481), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (7472, 7481), False, 'import os\n'), ((881, 929), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (['long_text'], {'max_tokens': '(1000)'}), '(long_text, max_tokens=1000)\n', (901, 929), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1256, 1293), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1268, 1293), False, 'import os\n'), ((1472, 1509), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1484, 1509), False, 'import os\n'), ((1534, 1571), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1546, 1571), False, 'import os\n'), ((1589, 1642), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (1610, 1642), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1780, 1808), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['test_dir'], {}), '(test_dir)\n', (1798, 1808), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1892, 1929), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1904, 1929), False, 'import os\n'), ((1954, 1991), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1966, 1991), False, 'import os\n'), ((2008, 2058), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (2026, 2058), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2161, 2194), 'autogen.retrieve_utils.is_url', 'is_url', (['"""https://www.example.com"""'], {}), "('https://www.example.com')\n", (2167, 2194), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2349, 2372), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (2363, 2372), False, 'import os\n'), ((2736, 2759), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (2750, 2759), False, 'import os\n'), ((3030, 3073), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client'}), "(['autogen'], client=client)\n", (3045, 3073), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6070, 6109), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (6095, 6109), False, 'import chromadb\n'), ((6398, 6495), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client', 'collection_name': '"""mytestcollection"""', 'n_results': '(1)'}), "(['autogen'], client=client, collection_name=\n 'mytestcollection', n_results=1)\n", (6413, 6495), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6801, 6848), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""/tmp/chromadb"""'}), "(path='/tmp/chromadb')\n", (6826, 6848), False, 'import chromadb\n'), ((6857, 6960), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', ([], {'dir_path': '"""./website/docs"""', 'client': 'client', 'collection_name': '"""autogen-docs"""'}), "(dir_path='./website/docs', client=client,\n collection_name='autogen-docs')\n", (6882, 6960), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6975, 7185), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', ([], {'query_texts': "['How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ]", 'n_results': '(4)', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'search_string': '"""AutoGen"""'}), "(query_texts=[\n 'How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ], n_results=4, client=client, collection_name='autogen-docs',\n search_string='AutoGen')\n", (6990, 7185), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((7491, 7509), 'os.remove', 'os.remove', (['db_path'], {}), '(db_path)\n', (7500, 7509), False, 'import os\n'), ((1081, 1110), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1094, 1110), False, 'import pytest\n'), ((1124, 1188), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (["('A' * 10000)"], {'chunk_mode': '"""bogus_chunk_mode"""'}), "('A' * 10000, chunk_mode='bogus_chunk_mode')\n", (1144, 1188), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2214, 2233), 'autogen.retrieve_utils.is_url', 'is_url', (['"""not_a_url"""'], {}), "('not_a_url')\n", (2220, 2233), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2395, 2434), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2420, 2434), False, 'import chromadb\n'), ((2470, 2509), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2495, 2509), False, 'import chromadb\n'), ((2522, 2572), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (2547, 2572), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2782, 2821), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2807, 2821), False, 'import chromadb\n'), ((2908, 2947), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2933, 2947), False, 'import chromadb\n'), ((2960, 3010), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (2985, 3010), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3494, 3518), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (3509, 3518), False, 'import lancedb\n'), ((6157, 6194), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (6169, 6194), False, 'import os\n'), ((1828, 1848), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (1842, 1848), False, 'import os\n'), ((2078, 2098), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2092, 2098), False, 'import os\n'), ((4574, 4598), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (4589, 4598), False, 'import lancedb\n'), ((949, 967), 'autogen.token_count_utils.count_token', 'count_token', (['chunk'], {}), '(chunk)\n', (960, 967), False, 'from autogen.token_count_utils import count_token\n'), ((1351, 1387), 'autogen.retrieve_utils.extract_text_from_pdf', 'extract_text_from_pdf', (['pdf_file_path'], {}), '(pdf_file_path)\n', (1372, 1387), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n')] |
"""
Unit test for retrieve_utils.py
"""
from autogen.retrieve_utils import (
split_text_to_chunks,
extract_text_from_pdf,
split_files_to_chunks,
get_files_from_dir,
is_url,
create_vector_db_from_dir,
query_vector_db,
)
from autogen.token_count_utils import count_token
import os
import pytest
import chromadb
test_dir = os.path.join(os.path.dirname(__file__), "test_files")
expected_text = """AutoGen is an advanced tool designed to assist developers in harnessing the capabilities
of Large Language Models (LLMs) for various applications. The primary purpose of AutoGen is to automate and
simplify the process of building applications that leverage the power of LLMs, allowing for seamless
integration, testing, and deployment."""
class TestRetrieveUtils:
def test_split_text_to_chunks(self):
long_text = "A" * 10000
chunks = split_text_to_chunks(long_text, max_tokens=1000)
assert all(count_token(chunk) <= 1000 for chunk in chunks)
def test_split_text_to_chunks_raises_on_invalid_chunk_mode(self):
with pytest.raises(AssertionError):
split_text_to_chunks("A" * 10000, chunk_mode="bogus_chunk_mode")
def test_extract_text_from_pdf(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
assert "".join(expected_text.split()) == "".join(extract_text_from_pdf(pdf_file_path).strip().split())
def test_split_files_to_chunks(self):
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
chunks = split_files_to_chunks([pdf_file_path, txt_file_path])
assert all(isinstance(chunk, str) and chunk.strip() for chunk in chunks)
def test_get_files_from_dir(self):
files = get_files_from_dir(test_dir)
assert all(os.path.isfile(file) for file in files)
pdf_file_path = os.path.join(test_dir, "example.pdf")
txt_file_path = os.path.join(test_dir, "example.txt")
files = get_files_from_dir([pdf_file_path, txt_file_path])
assert all(os.path.isfile(file) for file in files)
def test_is_url(self):
assert is_url("https://www.example.com")
assert not is_url("not_a_url")
def test_create_vector_db_from_dir(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else:
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
assert client.get_collection("all-my-documents")
def test_query_vector_db(self):
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
client = chromadb.PersistentClient(path=db_path)
else: # If the database does not exist, create it first
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(test_dir, client=client)
results = query_vector_db(["autogen"], client=client)
assert isinstance(results, dict) and any("autogen" in res[0].lower() for res in results.get("documents", []))
def test_custom_vector_db(self):
try:
import lancedb
except ImportError:
return
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
db_path = "/tmp/lancedb"
def create_lancedb():
db = lancedb.connect(db_path)
data = [
{"vector": [1.1, 1.2], "id": 1, "documents": "This is a test document spark"},
{"vector": [0.2, 1.8], "id": 2, "documents": "This is another test document"},
{"vector": [0.1, 0.3], "id": 3, "documents": "This is a third test document spark"},
{"vector": [0.5, 0.7], "id": 4, "documents": "This is a fourth test document"},
{"vector": [2.1, 1.3], "id": 5, "documents": "This is a fifth test document spark"},
{"vector": [5.1, 8.3], "id": 6, "documents": "This is a sixth test document"},
]
try:
db.create_table("my_table", data)
except OSError:
pass
class MyRetrieveUserProxyAgent(RetrieveUserProxyAgent):
def query_vector_db(
self,
query_texts,
n_results=10,
search_string="",
):
if query_texts:
vector = [0.1, 0.3]
db = lancedb.connect(db_path)
table = db.open_table("my_table")
query = table.search(vector).where(f"documents LIKE '%{search_string}%'").limit(n_results).to_df()
return {"ids": [query["id"].tolist()], "documents": [query["documents"].tolist()]}
def retrieve_docs(self, problem: str, n_results: int = 20, search_string: str = ""):
results = self.query_vector_db(
query_texts=[problem],
n_results=n_results,
search_string=search_string,
)
self._results = results
print("doc_ids: ", results["ids"])
ragragproxyagent = MyRetrieveUserProxyAgent(
name="ragproxyagent",
human_input_mode="NEVER",
max_consecutive_auto_reply=2,
retrieve_config={
"task": "qa",
"chunk_token_size": 2000,
"client": "__",
"embedding_model": "all-mpnet-base-v2",
},
)
create_lancedb()
ragragproxyagent.retrieve_docs("This is a test document spark", n_results=10, search_string="spark")
assert ragragproxyagent._results["ids"] == [[3, 1, 5]]
def test_custom_text_split_function(self):
def custom_text_split_function(text):
return [text[: len(text) // 2], text[len(text) // 2 :]]
db_path = "/tmp/test_retrieve_utils_chromadb.db"
client = chromadb.PersistentClient(path=db_path)
create_vector_db_from_dir(
os.path.join(test_dir, "example.txt"),
client=client,
collection_name="mytestcollection",
custom_text_split_function=custom_text_split_function,
get_or_create=True,
)
results = query_vector_db(["autogen"], client=client, collection_name="mytestcollection", n_results=1)
assert (
results.get("documents")[0][0]
== "AutoGen is an advanced tool designed to assist developers in harnessing the capabilities\nof Large Language Models (LLMs) for various applications. The primary purpose o"
)
def test_retrieve_utils(self):
client = chromadb.PersistentClient(path="/tmp/chromadb")
create_vector_db_from_dir(dir_path="./website/docs", client=client, collection_name="autogen-docs")
results = query_vector_db(
query_texts=[
"How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?",
],
n_results=4,
client=client,
collection_name="autogen-docs",
search_string="AutoGen",
)
print(results["ids"][0])
assert len(results["ids"][0]) == 4
if __name__ == "__main__":
pytest.main()
db_path = "/tmp/test_retrieve_utils_chromadb.db"
if os.path.exists(db_path):
os.remove(db_path) # Delete the database file after tests are finished
| [
"lancedb.connect"
] | [((365, 390), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (380, 390), False, 'import os\n'), ((7383, 7396), 'pytest.main', 'pytest.main', ([], {}), '()\n', (7394, 7396), False, 'import pytest\n'), ((7458, 7481), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (7472, 7481), False, 'import os\n'), ((881, 929), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (['long_text'], {'max_tokens': '(1000)'}), '(long_text, max_tokens=1000)\n', (901, 929), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1256, 1293), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1268, 1293), False, 'import os\n'), ((1472, 1509), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1484, 1509), False, 'import os\n'), ((1534, 1571), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1546, 1571), False, 'import os\n'), ((1589, 1642), 'autogen.retrieve_utils.split_files_to_chunks', 'split_files_to_chunks', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (1610, 1642), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1780, 1808), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['test_dir'], {}), '(test_dir)\n', (1798, 1808), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((1892, 1929), 'os.path.join', 'os.path.join', (['test_dir', '"""example.pdf"""'], {}), "(test_dir, 'example.pdf')\n", (1904, 1929), False, 'import os\n'), ((1954, 1991), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (1966, 1991), False, 'import os\n'), ((2008, 2058), 'autogen.retrieve_utils.get_files_from_dir', 'get_files_from_dir', (['[pdf_file_path, txt_file_path]'], {}), '([pdf_file_path, txt_file_path])\n', (2026, 2058), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2161, 2194), 'autogen.retrieve_utils.is_url', 'is_url', (['"""https://www.example.com"""'], {}), "('https://www.example.com')\n", (2167, 2194), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2349, 2372), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (2363, 2372), False, 'import os\n'), ((2736, 2759), 'os.path.exists', 'os.path.exists', (['db_path'], {}), '(db_path)\n', (2750, 2759), False, 'import os\n'), ((3030, 3073), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client'}), "(['autogen'], client=client)\n", (3045, 3073), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6070, 6109), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (6095, 6109), False, 'import chromadb\n'), ((6398, 6495), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', (["['autogen']"], {'client': 'client', 'collection_name': '"""mytestcollection"""', 'n_results': '(1)'}), "(['autogen'], client=client, collection_name=\n 'mytestcollection', n_results=1)\n", (6413, 6495), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6801, 6848), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""/tmp/chromadb"""'}), "(path='/tmp/chromadb')\n", (6826, 6848), False, 'import chromadb\n'), ((6857, 6960), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', ([], {'dir_path': '"""./website/docs"""', 'client': 'client', 'collection_name': '"""autogen-docs"""'}), "(dir_path='./website/docs', client=client,\n collection_name='autogen-docs')\n", (6882, 6960), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((6975, 7185), 'autogen.retrieve_utils.query_vector_db', 'query_vector_db', ([], {'query_texts': "['How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ]", 'n_results': '(4)', 'client': 'client', 'collection_name': '"""autogen-docs"""', 'search_string': '"""AutoGen"""'}), "(query_texts=[\n 'How can I use AutoGen UserProxyAgent and AssistantAgent to do code generation?'\n ], n_results=4, client=client, collection_name='autogen-docs',\n search_string='AutoGen')\n", (6990, 7185), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((7491, 7509), 'os.remove', 'os.remove', (['db_path'], {}), '(db_path)\n', (7500, 7509), False, 'import os\n'), ((1081, 1110), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1094, 1110), False, 'import pytest\n'), ((1124, 1188), 'autogen.retrieve_utils.split_text_to_chunks', 'split_text_to_chunks', (["('A' * 10000)"], {'chunk_mode': '"""bogus_chunk_mode"""'}), "('A' * 10000, chunk_mode='bogus_chunk_mode')\n", (1144, 1188), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2214, 2233), 'autogen.retrieve_utils.is_url', 'is_url', (['"""not_a_url"""'], {}), "('not_a_url')\n", (2220, 2233), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2395, 2434), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2420, 2434), False, 'import chromadb\n'), ((2470, 2509), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2495, 2509), False, 'import chromadb\n'), ((2522, 2572), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (2547, 2572), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((2782, 2821), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2807, 2821), False, 'import chromadb\n'), ((2908, 2947), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': 'db_path'}), '(path=db_path)\n', (2933, 2947), False, 'import chromadb\n'), ((2960, 3010), 'autogen.retrieve_utils.create_vector_db_from_dir', 'create_vector_db_from_dir', (['test_dir'], {'client': 'client'}), '(test_dir, client=client)\n', (2985, 3010), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n'), ((3494, 3518), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (3509, 3518), False, 'import lancedb\n'), ((6157, 6194), 'os.path.join', 'os.path.join', (['test_dir', '"""example.txt"""'], {}), "(test_dir, 'example.txt')\n", (6169, 6194), False, 'import os\n'), ((1828, 1848), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (1842, 1848), False, 'import os\n'), ((2078, 2098), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (2092, 2098), False, 'import os\n'), ((4574, 4598), 'lancedb.connect', 'lancedb.connect', (['db_path'], {}), '(db_path)\n', (4589, 4598), False, 'import lancedb\n'), ((949, 967), 'autogen.token_count_utils.count_token', 'count_token', (['chunk'], {}), '(chunk)\n', (960, 967), False, 'from autogen.token_count_utils import count_token\n'), ((1351, 1387), 'autogen.retrieve_utils.extract_text_from_pdf', 'extract_text_from_pdf', (['pdf_file_path'], {}), '(pdf_file_path)\n', (1372, 1387), False, 'from autogen.retrieve_utils import split_text_to_chunks, extract_text_from_pdf, split_files_to_chunks, get_files_from_dir, is_url, create_vector_db_from_dir, query_vector_db\n')] |
import os
import lancedb
import shutil
import uvicorn
import openai
from fastapi import FastAPI, HTTPException, WebSocket, UploadFile, File
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import PromptTemplate
from langchain.document_loaders import PyPDFLoader
from langchain.vectorstores import LanceDB
from langchain.text_splitter import RecursiveCharacterTextSplitter
from fastapi import FastAPI, HTTPException, UploadFile, File
from pydantic import BaseModel
# Initialize FastAPI app with metadata
app = FastAPI(
title="Chatbot RAG API",
description="This is a chatbot API template for RAG system.",
version="1.0.0",
)
# Pydantic model for chatbot request and response
class ChatRequest(BaseModel):
prompt: str
class ChatResponse(BaseModel):
response: str
# Global variable to store the path of the uploaded file
uploaded_file_path = None
# Endpoint to upload PDF
@app.post("/upload-pdf/")
async def upload_pdf(file: UploadFile = File(...)):
global uploaded_file_path
uploaded_file_path = f"uploaded_files/{file.filename}"
os.makedirs(os.path.dirname(uploaded_file_path), exist_ok=True)
with open(uploaded_file_path, "wb") as buffer:
shutil.copyfileobj(file.file, buffer)
return {"filename": file.filename}
# Setup LangChain
def setup_chain():
global uploaded_file_path
if not uploaded_file_path or not os.path.exists(uploaded_file_path):
raise HTTPException(
status_code=400, detail="No PDF file uploaded or file not found."
)
template = """Use the following pieces of context to answer the question at the end.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
Use three sentences maximum and keep the answer as concise as possible.
{context}
Question: {question}
Helpful Answer:"""
OPENAI_API_KEY = "sk-yourkey"
loader = PyPDFLoader(uploaded_file_path)
docs = loader.load_and_split()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=50)
documents = text_splitter.split_documents(docs)
prompt = PromptTemplate(input_variables=["context", "question"], template=template)
embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
db_lance = lancedb.connect("/tmp/lancedb")
table = db_lance.create_table(
"my_table",
data=[
{
"vector": embeddings.embed_query("Hello World"),
"text": "Hello World",
"id": "1",
}
],
mode="overwrite",
)
db = LanceDB.from_documents(documents, embeddings, connection=table)
retriever = db.as_retriever()
chain_type_kwargs = {"prompt": prompt}
llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY)
chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
chain_type_kwargs=chain_type_kwargs,
verbose=True,
)
return chain
# WebSocket endpoint for chat interaction
@app.websocket("/ws/chat")
async def websocket_chat(websocket: WebSocket):
await websocket.accept()
try:
while True:
data = await websocket.receive_text()
try:
agent = (
setup_chain()
) # Setup agent for each request to use the latest uploaded file
response = agent.run(data)
await websocket.send_text(response)
except Exception as e:
await websocket.send_text(f"Error: {str(e)}")
except Exception as e:
await websocket.close(code=1001, reason=str(e))
# Endpoint for chatbot interaction
@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
agent = setup_chain()
response = agent.run(request.prompt)
return {"response": response}
# Health check endpoint
@app.get("/", tags=["Health Check"])
async def read_root():
return {"message": "Chatbot API is running!"}
# Main function to run the app
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)
| [
"lancedb.connect"
] | [((621, 737), 'fastapi.FastAPI', 'FastAPI', ([], {'title': '"""Chatbot RAG API"""', 'description': '"""This is a chatbot API template for RAG system."""', 'version': '"""1.0.0"""'}), "(title='Chatbot RAG API', description=\n 'This is a chatbot API template for RAG system.', version='1.0.0')\n", (628, 737), False, 'from fastapi import FastAPI, HTTPException, UploadFile, File\n'), ((1075, 1084), 'fastapi.File', 'File', (['...'], {}), '(...)\n', (1079, 1084), False, 'from fastapi import FastAPI, HTTPException, UploadFile, File\n'), ((2017, 2048), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['uploaded_file_path'], {}), '(uploaded_file_path)\n', (2028, 2048), False, 'from langchain.document_loaders import PyPDFLoader\n'), ((2105, 2169), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(200)', 'chunk_overlap': '(50)'}), '(chunk_size=200, chunk_overlap=50)\n', (2135, 2169), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((2236, 2310), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['context', 'question']", 'template': 'template'}), "(input_variables=['context', 'question'], template=template)\n", (2250, 2310), False, 'from langchain.prompts import PromptTemplate\n'), ((2328, 2375), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'OPENAI_API_KEY'}), '(openai_api_key=OPENAI_API_KEY)\n', (2344, 2375), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((2392, 2423), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (2407, 2423), False, 'import lancedb\n'), ((2706, 2769), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['documents', 'embeddings'], {'connection': 'table'}), '(documents, embeddings, connection=table)\n', (2728, 2769), False, 'from langchain.vectorstores import LanceDB\n'), ((2858, 2899), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': 'OPENAI_API_KEY'}), '(openai_api_key=OPENAI_API_KEY)\n', (2868, 2899), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2913, 3046), 'langchain.chains.RetrievalQA.from_chain_type', 'RetrievalQA.from_chain_type', ([], {'llm': 'llm', 'chain_type': '"""stuff"""', 'retriever': 'retriever', 'chain_type_kwargs': 'chain_type_kwargs', 'verbose': '(True)'}), "(llm=llm, chain_type='stuff', retriever=\n retriever, chain_type_kwargs=chain_type_kwargs, verbose=True)\n", (2940, 3046), False, 'from langchain.chains import RetrievalQA\n'), ((4191, 4234), 'uvicorn.run', 'uvicorn.run', (['app'], {'host': '"""0.0.0.0"""', 'port': '(8000)'}), "(app, host='0.0.0.0', port=8000)\n", (4202, 4234), False, 'import uvicorn\n'), ((1192, 1227), 'os.path.dirname', 'os.path.dirname', (['uploaded_file_path'], {}), '(uploaded_file_path)\n', (1207, 1227), False, 'import os\n'), ((1303, 1340), 'shutil.copyfileobj', 'shutil.copyfileobj', (['file.file', 'buffer'], {}), '(file.file, buffer)\n', (1321, 1340), False, 'import shutil\n'), ((1536, 1621), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(400)', 'detail': '"""No PDF file uploaded or file not found."""'}), "(status_code=400, detail='No PDF file uploaded or file not found.'\n )\n", (1549, 1621), False, 'from fastapi import FastAPI, HTTPException, UploadFile, File\n'), ((1486, 1520), 'os.path.exists', 'os.path.exists', (['uploaded_file_path'], {}), '(uploaded_file_path)\n', (1500, 1520), False, 'import os\n')] |
import os
import typer
import pickle
import pandas as pd
from dotenv import load_dotenv
import openai
import pinecone
import lancedb
import pyarrow as pa
from collections import deque
TASK_CREATION_PROMPT = """
You are an task creation AI that uses the result of an execution agent to create new tasks with the following objective:
{objective}, The last completed task has the result: {result}. This result was based on this task description: {task_description}.
These are incomplete tasks: {task_list}. Based on the result, create new tasks to be completed by the AI system that
do not overlap with incomplete tasks. Return the tasks as an array."""
PRIORITIZATION_PROMPT = """
You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing
the following tasks: {task_names}. Consider the ultimate objective of your team:{objective}. Do not remove any tasks.
Return the result as a numbered list, like:
#. First task
#. Second task
Start the task list with number {next_task_id}."""
EXECUTION_PROMPT = """
You are an AI who performs one task based on the following objective: {objective}. Your task: {task}\nResponse:
"""
class OpenAIService:
def __init__(self, api_key):
openai.api_key = api_key
def get_ada_embedding(self, text):
text = text.replace('\n', ' ')
return openai.Embedding.create(input=[text], model='text-embedding-ada-002')['data'][0]['embedding']
def create(self, prompt, max_tokens=100, temperature=0.5):
return (
openai.Completion.create(
engine='text-davinci-003',
prompt=prompt,
temperature=temperature,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
)
.choices[0]
.text.strip()
)
class TestAIService:
def __init__(self, ai_service, cache_file):
self.ai_service = ai_service
self.cache_file = cache_file
if os.path.isfile(cache_file):
self.cache = pickle.load(open(cache_file, 'rb'))
else:
self.cache = {'ada': {}, 'create': {}}
pickle.dump(self.cache, open(cache_file, 'wb'))
def get_ada_embedding(self, text):
if text not in self.cache['ada']:
self.cache['ada'][text] = self.ai_service.get_ada_embedding(text)
pickle.dump(self.cache, open(self.cache_file, 'wb'))
return self.cache['ada'][text]
def create(self, prompt, max_tokens=100, temperature=0.5):
key = (prompt, max_tokens, temperature)
if key not in self.cache['create']:
self.cache['create'][key] = self.ai_service.create(prompt, max_tokens, temperature)
pickle.dump(self.cache, open(self.cache_file, 'wb'))
return self.cache['create'][key]
class PineconeService:
def __init__(self, api_key, environment, table_name, dimension, metric, pod_type):
self.table_name = table_name
pinecone.init(api_key=api_key, environment=environment)
if table_name not in pinecone.list_indexes():
pinecone.create_index(table_name, dimension=dimension, metric=metric, pod_type=pod_type)
self.index = pinecone.Index(table_name)
def query(self, query_embedding, top_k):
results = self.index.query(query_embedding, top_k=top_k, include_metadata=True)
sorted_results = sorted(results.matches, key=lambda x: x.score, reverse=True)
return [(str(item.metadata['task'])) for item in sorted_results]
def upsert(self, data):
self.index.upsert(data)
class LanceService:
def __init__(self, table_name, dimension):
self.db = lancedb.connect('.')
schema = pa.schema(
[
pa.field('result_id', pa.string()),
pa.field('vector', pa.list_(pa.float32(), dimension)),
pa.field('task', pa.string()),
pa.field('result', pa.string()), # TODO There is a fixed schema but we keep converting
]
)
data = [{'result_id': 0, 'vector': [0.0] * dimension, 'task': 'asd', 'result': 'asd'}]
self.table = self.db.create_table(table_name, mode='overwrite', data=data, schema=schema)
def query(self, query_embedding, top_k):
result = self.table.search(query_embedding).limit(top_k).to_df()
return [v for v in result['task']]
def upsert(self, data):
data = { # TODO This doesn't look good, why are we converting?
'result_id': data[0][0],
'vector': data[0][1],
'task': data[0][2]['task'],
'result': data[0][2]['result'],
}
self.table.add(pd.DataFrame([data]))
class BabyAGI:
def __init__(self, objective, ai_service, vector_service):
self.objective = objective
self.ai_service = ai_service
self.vector_service = vector_service
self.task_list = deque([])
def add_task(self, task):
self.task_list.append(task)
def task_creation_agent(self, result, task_description):
prompt = TASK_CREATION_PROMPT.format(
objective=self.objective,
result=result,
task_description=task_description,
task_list=', '.join([t['task_name'] for t in self.task_list]),
)
response = self.ai_service.create(prompt)
new_tasks = response.split('\n')
return [{'task_name': task_name} for task_name in new_tasks]
def prioritization_agent(self, this_task_id):
task_names = [t['task_name'] for t in self.task_list]
next_task_id = int(this_task_id) + 1
prompt = PRIORITIZATION_PROMPT.format(
task_names=task_names, objective=self.objective, next_task_id=next_task_id
)
response = self.ai_service.create(prompt, max_tokens=1000)
new_tasks = response.split('\n')
self.task_list = deque()
for task_string in new_tasks:
task_parts = task_string.strip().split('.', 1)
if len(task_parts) == 2:
task_id = task_parts[0].strip()
task_name = task_parts[1].strip()
self.task_list.append({'task_id': task_id, 'task_name': task_name})
def execution_agent(self, task) -> str:
context = self.context_agent(query=self.objective, n=5)
response = self.ai_service.create(
prompt=EXECUTION_PROMPT.format(objective=self.objective, task=task), max_tokens=2000, temperature=0.7
)
return response
def context_agent(self, query, n):
query_embedding = self.ai_service.get_ada_embedding(query)
return self.vector_service.query(query_embedding, n)
def run(self, first_task):
print(self.objective)
first_task = {'task_id': 1, 'task_name': first_task}
self.add_task(first_task)
task_id_counter = 1
for _ in range(4):
if self.task_list:
task = self.task_list.popleft()
print(task['task_name'])
result = self.execution_agent(task['task_name'])
print(result)
this_task_id = int(task['task_id'])
enriched_result = {'data': result}
result_id = f'result_{task["task_id"]}'
vector = enriched_result['data']
self.vector_service.upsert(
[
(
result_id,
self.ai_service.get_ada_embedding(vector),
{'task': task['task_name'], 'result': result},
)
]
)
new_tasks = self.task_creation_agent(enriched_result, task['task_name'])
for new_task in new_tasks:
task_id_counter += 1
new_task.update({'task_id': task_id_counter})
self.add_task(new_task)
self.prioritization_agent(this_task_id)
def main():
load_dotenv()
baby_agi = BabyAGI(
objective='Solve world hunger.',
ai_service=TestAIService(
ai_service=OpenAIService(api_key=os.getenv('OPENAI_API_KEY')),
cache_file='babyagi_cache.pkl',
),
vector_service=LanceService(
table_name='test-table',
dimension=1536,
)
# vector_service=PineconeService(
# api_key=os.getenv('PINECONE_API_KEY'),
# environment=os.getenv('PINECONE_ENVIRONMENT'),
# table_name='test-table',
# dimension=1536,
# metric='cosine',
# pod_type='p1',
# ),
)
baby_agi.run(first_task='Develop a task list.')
if __name__ == '__main__':
typer.run(main)
| [
"lancedb.connect"
] | [((8057, 8070), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (8068, 8070), False, 'from dotenv import load_dotenv\n'), ((8801, 8816), 'typer.run', 'typer.run', (['main'], {}), '(main)\n', (8810, 8816), False, 'import typer\n'), ((2034, 2060), 'os.path.isfile', 'os.path.isfile', (['cache_file'], {}), '(cache_file)\n', (2048, 2060), False, 'import os\n'), ((3027, 3082), 'pinecone.init', 'pinecone.init', ([], {'api_key': 'api_key', 'environment': 'environment'}), '(api_key=api_key, environment=environment)\n', (3040, 3082), False, 'import pinecone\n'), ((3259, 3285), 'pinecone.Index', 'pinecone.Index', (['table_name'], {}), '(table_name)\n', (3273, 3285), False, 'import pinecone\n'), ((3727, 3747), 'lancedb.connect', 'lancedb.connect', (['"""."""'], {}), "('.')\n", (3742, 3747), False, 'import lancedb\n'), ((4976, 4985), 'collections.deque', 'deque', (['[]'], {}), '([])\n', (4981, 4985), False, 'from collections import deque\n'), ((5953, 5960), 'collections.deque', 'deque', ([], {}), '()\n', (5958, 5960), False, 'from collections import deque\n'), ((3112, 3135), 'pinecone.list_indexes', 'pinecone.list_indexes', ([], {}), '()\n', (3133, 3135), False, 'import pinecone\n'), ((3149, 3241), 'pinecone.create_index', 'pinecone.create_index', (['table_name'], {'dimension': 'dimension', 'metric': 'metric', 'pod_type': 'pod_type'}), '(table_name, dimension=dimension, metric=metric,\n pod_type=pod_type)\n', (3170, 3241), False, 'import pinecone\n'), ((4732, 4752), 'pandas.DataFrame', 'pd.DataFrame', (['[data]'], {}), '([data])\n', (4744, 4752), True, 'import pandas as pd\n'), ((1339, 1408), 'openai.Embedding.create', 'openai.Embedding.create', ([], {'input': '[text]', 'model': '"""text-embedding-ada-002"""'}), "(input=[text], model='text-embedding-ada-002')\n", (1362, 1408), False, 'import openai\n'), ((3828, 3839), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (3837, 3839), True, 'import pyarrow as pa\n'), ((3946, 3957), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (3955, 3957), True, 'import pyarrow as pa\n'), ((3995, 4006), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (4004, 4006), True, 'import pyarrow as pa\n'), ((3886, 3898), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (3896, 3898), True, 'import pyarrow as pa\n'), ((1526, 1698), 'openai.Completion.create', 'openai.Completion.create', ([], {'engine': '"""text-davinci-003"""', 'prompt': 'prompt', 'temperature': 'temperature', 'max_tokens': 'max_tokens', 'top_p': '(1)', 'frequency_penalty': '(0)', 'presence_penalty': '(0)'}), "(engine='text-davinci-003', prompt=prompt,\n temperature=temperature, max_tokens=max_tokens, top_p=1,\n frequency_penalty=0, presence_penalty=0)\n", (1550, 1698), False, 'import openai\n'), ((8215, 8242), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (8224, 8242), False, 'import os\n')] |
import openai
import os
import lancedb
import pickle
import requests
from pathlib import Path
from bs4 import BeautifulSoup
import re
from langchain.document_loaders import UnstructuredHTMLLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import LanceDB
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
# Function to fetch and save a page as an HTML file
def save_page(url, save_dir):
response = requests.get(url)
if response.status_code == 200:
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.find('title').text
filename = f"{title}.html"
with open(os.path.join(save_dir, filename), 'w', encoding='utf-8') as file:
file.write(str(soup))
def get_document_title(document):
m = str(document.metadata["source"])
title = re.findall("(.*)\.html", m)
print("PRINTING TITLES")
print(title)
if title[0] is not None:
return(title[0])
return ''
# if "OPENAI_API_KEY" not in os.environ:
openai.api_key = "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"
assert len(openai.Model.list()["data"]) > 0
print("fetching data")
# Base URL of Wikivoyage
base_url = "https://en.wikivoyage.org/wiki/"
# List of page titles to download
page_titles = ["London", "Paris", "New_York_City"] # Add more as needed
# Directory to save the HTML files
save_directory = "./wikivoyage_pages"
# Create the save directory if it doesn't exist
if not os.path.exists(save_directory):
os.makedirs(save_directory)
# Loop through the page titles and download the pages
for title in page_titles:
url = f"{base_url}{title}"
save_page(url, save_directory)
docs_path = Path("cities.pkl")
docs = []
if not docs_path.exists():
for p in Path("./wikivoyage_pages").rglob("*.html"):
if p.is_dir():
continue
loader = UnstructuredHTMLLoader(p)
raw_document = loader.load()
m = {}
m["title"] = get_document_title(raw_document[0])
raw_document[0].metadata = raw_document[0].metadata | m
raw_document[0].metadata["source"] = str(raw_document[0].metadata["source"])
docs = docs + raw_document
with docs_path.open("wb") as fh:
pickle.dump(docs, fh)
else:
with docs_path.open("rb") as fh:
docs = pickle.load(fh)
#split text
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=50,
)
documents = text_splitter.split_documents(docs)
embeddings = OpenAIEmbeddings(openai_api_key="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")
db = lancedb.connect('/tmp/lancedb')
table = db.create_table("city_docs", data=[
{"vector": embeddings.embed_query("Hello World"), "text": "Hello World"}
], mode="overwrite")
print("generated embeddings!")
docsearch = LanceDB.from_documents(documents[5:], embeddings, connection=table)
qa = RetrievalQA.from_chain_type(llm=OpenAI(openai_api_key="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"), chain_type="stuff", retriever=docsearch.as_retriever())
query_file = open('query.pkl', 'wb')
pickle.dump(qa, query_file)
query_file.close()
print("returning query object") | [
"lancedb.connect"
] | [((1788, 1806), 'pathlib.Path', 'Path', (['"""cities.pkl"""'], {}), "('cities.pkl')\n", (1792, 1806), False, 'from pathlib import Path\n'), ((2462, 2526), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(500)', 'chunk_overlap': '(50)'}), '(chunk_size=500, chunk_overlap=50)\n', (2492, 2526), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((2601, 2692), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': '"""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"""'}), "(openai_api_key=\n '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')\n", (2617, 2692), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((2694, 2725), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (2709, 2725), False, 'import lancedb\n'), ((2913, 2980), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['documents[5:]', 'embeddings'], {'connection': 'table'}), '(documents[5:], embeddings, connection=table)\n', (2935, 2980), False, 'from langchain.vectorstores import LanceDB\n'), ((3190, 3217), 'pickle.dump', 'pickle.dump', (['qa', 'query_file'], {}), '(qa, query_file)\n', (3201, 3217), False, 'import pickle\n'), ((530, 547), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (542, 547), False, 'import requests\n'), ((931, 959), 're.findall', 're.findall', (['"""(.*)\\\\.html"""', 'm'], {}), "('(.*)\\\\.html', m)\n", (941, 959), False, 'import re\n'), ((1564, 1594), 'os.path.exists', 'os.path.exists', (['save_directory'], {}), '(save_directory)\n', (1578, 1594), False, 'import os\n'), ((1600, 1627), 'os.makedirs', 'os.makedirs', (['save_directory'], {}), '(save_directory)\n', (1611, 1627), False, 'import os\n'), ((599, 645), 'bs4.BeautifulSoup', 'BeautifulSoup', (['response.content', '"""html.parser"""'], {}), "(response.content, 'html.parser')\n", (612, 645), False, 'from bs4 import BeautifulSoup\n'), ((1963, 1988), 'langchain.document_loaders.UnstructuredHTMLLoader', 'UnstructuredHTMLLoader', (['p'], {}), '(p)\n', (1985, 1988), False, 'from langchain.document_loaders import UnstructuredHTMLLoader\n'), ((2337, 2358), 'pickle.dump', 'pickle.dump', (['docs', 'fh'], {}), '(docs, fh)\n', (2348, 2358), False, 'import pickle\n'), ((2417, 2432), 'pickle.load', 'pickle.load', (['fh'], {}), '(fh)\n', (2428, 2432), False, 'import pickle\n'), ((3018, 3094), 'langchain.llms.OpenAI', 'OpenAI', ([], {'openai_api_key': '"""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"""'}), "(openai_api_key='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')\n", (3024, 3094), False, 'from langchain.llms import OpenAI\n'), ((1199, 1218), 'openai.Model.list', 'openai.Model.list', ([], {}), '()\n', (1216, 1218), False, 'import openai\n'), ((1858, 1884), 'pathlib.Path', 'Path', (['"""./wikivoyage_pages"""'], {}), "('./wikivoyage_pages')\n", (1862, 1884), False, 'from pathlib import Path\n'), ((739, 771), 'os.path.join', 'os.path.join', (['save_dir', 'filename'], {}), '(save_dir, filename)\n', (751, 771), False, 'import os\n')] |
from flask import Flask, render_template, jsonify, request
from scripts.mock_llm_api import llm_api
import lancedb
import pandas as pd
uri = "data/lancedb"
db = lancedb.connect(uri)
# Set initial entries in items vector database
def _reset_tables():
items = ['Fire', 'Earth', 'Water', 'Wind']
descriptions = ["Strength: 10\nCost: 300\nCategory: Element",
"Strength: 7\nCost: 100\nCategory: Element",
"Strength: 3\nCost: 50\nCategory: Element",
"Strength: 1\nCost: 10\nCategory: Element"
]
vectors = [llm_api.embedding_request(item) for item in items]
df = pd.DataFrame({"item": items, "vector": vectors, "description": descriptions})
db.create_table("items", mode="overwrite", data=df)
if not db.table_names():
print("No DB set up, creating initial tables")
_reset_tables()
app = Flask(__name__)
@app.route("/")
def hello_world():
table = db.open_table("items")
return render_template('index.html', items=table.to_pandas()['item'].values.tolist())
@app.route('/generate')
def generate():
item_1 = request.args.get('item_1', type=str)
item_2 = request.args.get('item_2', type=str)
# Generate prompt embedding
with open("prompt_templates/basic_embedding_prompt.txt") as embedding_prompt_file:
embedding_prompt_template = embedding_prompt_file.read().strip()
embeddding_prompt = embedding_prompt_template.format(item_1=item_1, item_2=item_2)
prompt_embedding = llm_api.embedding_request(embeddding_prompt)
# Generate combination
with open("prompt_templates/basic_prompt.txt") as prompt_file:
prompt_template = prompt_file.read().strip()
prompt = prompt_template.format(item_1=item_1, item_2=item_2)
combination = llm_api.completion_request(prompt, max_tokens=30)
# Generate description for combination
with open("prompt_templates/basic_description_prompt.txt") as description_prompt_file:
prompt_template = description_prompt_file.read().strip()
prompt = prompt_template.format(item=combination)
description = llm_api.completion_request(prompt, max_tokens=100)
# Add result to vector database
table = db.open_table("items")
table.add(pd.DataFrame([{"item": combination, "vector": llm_api.embedding_request(combination), "description": description}]))
return jsonify(result=combination)
@app.route('/get_description')
def get_description():
item = request.args.get('item', type=str)
table = db.open_table("items")
# Get description
# TODO: Important! This retrieves the whole database, which is very inefficient
# You may be tempted to do something like
# df = table.search(llm_api.embedding_request(item)).limit(1).to_df()
# description = df['description'].values.tolist()[0]
# instead. However, LanceDB is a bit unstable and will occasionally crash if you do this
# The ideal setup would be to have a standard SQL database for this lookup
df = table.to_pandas()
description = df[df["item"] == item]["description"].values[0]
return jsonify(result=description)
| [
"lancedb.connect"
] | [((162, 182), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (177, 182), False, 'import lancedb\n'), ((879, 894), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (884, 894), False, 'from flask import Flask, render_template, jsonify, request\n'), ((640, 717), 'pandas.DataFrame', 'pd.DataFrame', (["{'item': items, 'vector': vectors, 'description': descriptions}"], {}), "({'item': items, 'vector': vectors, 'description': descriptions})\n", (652, 717), True, 'import pandas as pd\n'), ((1111, 1147), 'flask.request.args.get', 'request.args.get', (['"""item_1"""'], {'type': 'str'}), "('item_1', type=str)\n", (1127, 1147), False, 'from flask import Flask, render_template, jsonify, request\n'), ((1161, 1197), 'flask.request.args.get', 'request.args.get', (['"""item_2"""'], {'type': 'str'}), "('item_2', type=str)\n", (1177, 1197), False, 'from flask import Flask, render_template, jsonify, request\n'), ((1505, 1549), 'scripts.mock_llm_api.llm_api.embedding_request', 'llm_api.embedding_request', (['embeddding_prompt'], {}), '(embeddding_prompt)\n', (1530, 1549), False, 'from scripts.mock_llm_api import llm_api\n'), ((1782, 1831), 'scripts.mock_llm_api.llm_api.completion_request', 'llm_api.completion_request', (['prompt'], {'max_tokens': '(30)'}), '(prompt, max_tokens=30)\n', (1808, 1831), False, 'from scripts.mock_llm_api import llm_api\n'), ((2104, 2154), 'scripts.mock_llm_api.llm_api.completion_request', 'llm_api.completion_request', (['prompt'], {'max_tokens': '(100)'}), '(prompt, max_tokens=100)\n', (2130, 2154), False, 'from scripts.mock_llm_api import llm_api\n'), ((2370, 2397), 'flask.jsonify', 'jsonify', ([], {'result': 'combination'}), '(result=combination)\n', (2377, 2397), False, 'from flask import Flask, render_template, jsonify, request\n'), ((2465, 2499), 'flask.request.args.get', 'request.args.get', (['"""item"""'], {'type': 'str'}), "('item', type=str)\n", (2481, 2499), False, 'from flask import Flask, render_template, jsonify, request\n'), ((3104, 3131), 'flask.jsonify', 'jsonify', ([], {'result': 'description'}), '(result=description)\n', (3111, 3131), False, 'from flask import Flask, render_template, jsonify, request\n'), ((579, 610), 'scripts.mock_llm_api.llm_api.embedding_request', 'llm_api.embedding_request', (['item'], {}), '(item)\n', (604, 610), False, 'from scripts.mock_llm_api import llm_api\n'), ((2287, 2325), 'scripts.mock_llm_api.llm_api.embedding_request', 'llm_api.embedding_request', (['combination'], {}), '(combination)\n', (2312, 2325), False, 'from scripts.mock_llm_api import llm_api\n')] |
import logging
import json
import gradio as gr
import numpy as np
import lancedb
import os
from huggingface_hub import AsyncInferenceClient
# Setting up the logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# db
TABLE_NAME = "docs"
TEXT_COLUMN = "text"
BATCH_SIZE = int(os.getenv("BATCH_SIZE"))
NPROBES = int(os.getenv("NPROBES"))
REFINE_FACTOR = int(os.getenv("REFINE_FACTOR"))
retriever = AsyncInferenceClient(model=os.getenv("EMBED_URL") + "/embed")
reranker = AsyncInferenceClient(model=os.getenv("RERANK_URL") + "/rerank")
db = lancedb.connect("/usr/src/.lancedb")
tbl = db.open_table(TABLE_NAME)
async def retrieve(query: str, k: int) -> list[str]:
"""
Retrieve top k items with RETRIEVER
"""
resp = await retriever.post(
json={
"inputs": query,
"truncate": True
}
)
try:
query_vec = json.loads(resp)[0]
except:
raise gr.Error(resp.decode())
documents = tbl.search(
query=query_vec
).nprobes(NPROBES).refine_factor(REFINE_FACTOR).limit(k).to_list()
documents = [doc[TEXT_COLUMN] for doc in documents]
return documents
async def rerank(query: str, documents: list[str], k: int) -> list[str]:
"""
Rerank items returned by RETRIEVER and return top k
"""
scores = []
for i in range(int(np.ceil(len(documents) / BATCH_SIZE))):
resp = await reranker.post(
json={
"query": query,
"texts": documents[i * BATCH_SIZE:(i + 1) * BATCH_SIZE],
"truncate": True
}
)
try:
batch_scores = json.loads(resp)
batch_scores = [s["score"] for s in batch_scores]
scores.extend(batch_scores)
except:
raise gr.Error(resp.decode())
documents = [doc for _, doc in sorted(zip(scores, documents))[-k:]]
return documents | [
"lancedb.connect"
] | [((167, 206), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (186, 206), False, 'import logging\n'), ((216, 243), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (233, 243), False, 'import logging\n'), ((573, 609), 'lancedb.connect', 'lancedb.connect', (['"""/usr/src/.lancedb"""'], {}), "('/usr/src/.lancedb')\n", (588, 609), False, 'import lancedb\n'), ((308, 331), 'os.getenv', 'os.getenv', (['"""BATCH_SIZE"""'], {}), "('BATCH_SIZE')\n", (317, 331), False, 'import os\n'), ((347, 367), 'os.getenv', 'os.getenv', (['"""NPROBES"""'], {}), "('NPROBES')\n", (356, 367), False, 'import os\n'), ((389, 415), 'os.getenv', 'os.getenv', (['"""REFINE_FACTOR"""'], {}), "('REFINE_FACTOR')\n", (398, 415), False, 'import os\n'), ((457, 479), 'os.getenv', 'os.getenv', (['"""EMBED_URL"""'], {}), "('EMBED_URL')\n", (466, 479), False, 'import os\n'), ((530, 553), 'os.getenv', 'os.getenv', (['"""RERANK_URL"""'], {}), "('RERANK_URL')\n", (539, 553), False, 'import os\n'), ((904, 920), 'json.loads', 'json.loads', (['resp'], {}), '(resp)\n', (914, 920), False, 'import json\n'), ((1663, 1679), 'json.loads', 'json.loads', (['resp'], {}), '(resp)\n', (1673, 1679), False, 'import json\n')] |
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
import os
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import LanceDB
from langchain.embeddings import BedrockEmbeddings
from langchain.document_loaders import PyPDFDirectoryLoader
import lancedb as ldb
import pyarrow as pa
embeddings = BedrockEmbeddings()
# we split the data into chunks of 1,000 characters, with an overlap
# of 200 characters between the chunks, which helps to give better results
# and contain the context of the information between chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
db = ldb.connect('/tmp/embeddings')
schema = pa.schema(
[
pa.field("vector", pa.list_(pa.float32(), 1536)), # document vector with 1.5k dimensions (TitanEmbedding)
pa.field("text", pa.string()), # langchain requires it
pa.field("id", pa.string()) # langchain requires it
])
tbl = db.create_table("doc_table", schema=schema)
# load the document as before
loader = PyPDFDirectoryLoader("./docs/")
docs = loader.load()
docs = text_splitter.split_documents(docs)
LanceDB.from_documents(docs, embeddings, connection=tbl)
| [
"lancedb.connect"
] | [((384, 403), 'langchain.embeddings.BedrockEmbeddings', 'BedrockEmbeddings', ([], {}), '()\n', (401, 403), False, 'from langchain.embeddings import BedrockEmbeddings\n'), ((625, 682), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(200)'}), '(chunk_size=1000, chunk_overlap=200)\n', (646, 682), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((689, 719), 'lancedb.connect', 'ldb.connect', (['"""/tmp/embeddings"""'], {}), "('/tmp/embeddings')\n", (700, 719), True, 'import lancedb as ldb\n'), ((1073, 1104), 'langchain.document_loaders.PyPDFDirectoryLoader', 'PyPDFDirectoryLoader', (['"""./docs/"""'], {}), "('./docs/')\n", (1093, 1104), False, 'from langchain.document_loaders import PyPDFDirectoryLoader\n'), ((1171, 1227), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['docs', 'embeddings'], {'connection': 'tbl'}), '(docs, embeddings, connection=tbl)\n', (1193, 1227), False, 'from langchain.vectorstores import LanceDB\n'), ((880, 891), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (889, 891), True, 'import pyarrow as pa\n'), ((939, 950), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (948, 950), True, 'import pyarrow as pa\n'), ((779, 791), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (789, 791), True, 'import pyarrow as pa\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from PIL import Image
from matplotlib import pyplot as plt
from pandas import DataFrame
from tqdm import tqdm
from engine.data.augment import Format
from engine.data.dataset import YOLODataset
from engine.data.utils import check_det_dataset
from engine.models.yolo.model import YOLO
from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self,
data: Union[str, Path] = "coco128.yaml",
model: str = "yolov8n.pt",
uri: str = USER_CONFIG_DIR / "explorer",
) -> None:
# Note duckdb==0.10.0 bug https://github.com/ultralytics/ultralytics/pull/8181
checks.check_requirements(["lancedb>=0.4.3", "duckdb<=0.9.2"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "arrow":
return rs.arrow()
elif return_type == "pandas":
return rs.df()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in {
"pandas",
"arrow",
}, f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "arrow":
return similar
elif return_type == "pandas":
return similar.to_pandas()
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1672, 1865), 'engine.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1678, 1865), False, 'from engine.data.augment import Format\n'), ((2245, 2307), 'engine.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb<=0.9.2']"], {}), "(['lancedb>=0.4.3', 'duckdb<=0.9.2'])\n", (2270, 2307), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2358, 2378), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2373, 2378), False, 'import lancedb\n'), ((2629, 2640), 'engine.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2633, 2640), False, 'from engine.models.yolo.model import YOLO\n'), ((3972, 4000), 'engine.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3989, 4000), False, 'from engine.data.utils import check_det_dataset\n'), ((8607, 8645), 'engine.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8618, 8645), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((8660, 8677), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8670, 8677), False, 'import duckdb\n'), ((9639, 9659), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9654, 9659), False, 'from PIL import Image\n'), ((12284, 12304), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12299, 12304), False, 'from PIL import Image\n'), ((16556, 16575), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16564, 16575), True, 'import numpy as np\n'), ((16660, 16687), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16667, 16687), True, 'from matplotlib import pyplot as plt\n'), ((16737, 16759), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16747, 16759), True, 'from matplotlib import pyplot as plt\n'), ((16768, 16787), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16778, 16787), True, 'from matplotlib import pyplot as plt\n'), ((16796, 16825), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16805, 16825), True, 'from matplotlib import pyplot as plt\n'), ((16843, 16852), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16850, 16852), False, 'from io import BytesIO\n'), ((16861, 16894), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16872, 16894), True, 'from matplotlib import pyplot as plt\n'), ((3433, 3519), 'engine.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3444, 3519), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((3621, 3731), 'engine.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3632, 3731), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((9507, 9539), 'engine.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9518, 9539), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((12151, 12183), 'engine.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12162, 12183), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((13761, 13864), 'engine.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13772, 13864), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((1182, 1193), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1189, 1193), True, 'import numpy as np\n'), ((1247, 1260), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1257, 1260), False, 'import cv2\n'), ((17014, 17032), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (17024, 17032), False, 'from PIL import Image\n'), ((18250, 18349), 'engine.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18262, 18349), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((18352, 18367), 'engine.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18364, 18367), False, 'from engine.utils import LOGGER, IterableSimpleNamespace, checks, USER_CONFIG_DIR\n'), ((2405, 2415), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2409, 2415), False, 'from pathlib import Path\n'), ((6832, 6851), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6843, 6851), False, 'import torch\n')] |
import pyarrow as pa
from typing import Union
from dryg.settings import DB_URI
import lancedb
def connection() -> lancedb.LanceDBConnection:
"""
Connect to the database
Returns:
lancedb.LanceDBConnection: LanceDBConnection object
"""
db = lancedb.connect(DB_URI)
return db
def open_table(table_name: str) -> Union[lancedb.table.LanceTable, None]:
"""
Open a table from the database
Args:
table_name (str): Name of the table
Returns:
lancedb.table.LanceTable: LanceTable object
"""
db = connection()
try:
table = db.open_table(table_name) if table_name in db.table_names() else None
return table
except ValueError:
return None
def create_table(table_name: str, table: pa.Table, mode: str = "overwrite") -> lancedb.LanceDBConnection:
"""
Create a table in the database
Args:
table_name (str): Name of the table
table (pa.Table): Table to be created
mode (str, optional): Mode to use when creating the table. Defaults to "overwrite".
Returns:
lancedb.LanceDBConnection: LanceDBConnection object
"""
db = connection()
db.create_table(table_name, table, mode=mode)
return db
| [
"lancedb.connect"
] | [((271, 294), 'lancedb.connect', 'lancedb.connect', (['DB_URI'], {}), '(DB_URI)\n', (286, 294), False, 'import lancedb\n')] |
import os
import typer
import pickle
import pandas as pd
from dotenv import load_dotenv
import openai
import pinecone
import lancedb
import pyarrow as pa
from collections import deque
TASK_CREATION_PROMPT = """
You are an task creation AI that uses the result of an execution agent to create new tasks with the following objective:
{objective}, The last completed task has the result: {result}. This result was based on this task description: {task_description}.
These are incomplete tasks: {task_list}. Based on the result, create new tasks to be completed by the AI system that
do not overlap with incomplete tasks. Return the tasks as an array."""
PRIORITIZATION_PROMPT = """
You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing
the following tasks: {task_names}. Consider the ultimate objective of your team:{objective}. Do not remove any tasks.
Return the result as a numbered list, like:
#. First task
#. Second task
Start the task list with number {next_task_id}."""
EXECUTION_PROMPT = """
You are an AI who performs one task based on the following objective: {objective}. Your task: {task}\nResponse:
"""
class Task:
def __init__(self, name, id=None, result=None, vector=None):
self.name = name
self.id = id
self.result = result
self.vector = vector
class OpenAIService:
def __init__(self, api_key):
openai.api_key = api_key
def get_ada_embedding(self, text):
return openai.Embedding.create(input=[text.replace('\n', ' ')], model='text-embedding-ada-002')['data'][0][
'embedding'
]
def create(self, prompt, max_tokens=100, temperature=0.5):
return (
openai.Completion.create(
engine='text-davinci-003',
prompt=prompt,
temperature=temperature,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
)
.choices[0]
.text.strip()
)
class TestAIService:
def __init__(self, ai_service, cache_file):
self.ai_service = ai_service
self.cache_file = cache_file
if os.path.isfile(cache_file):
self.cache = pickle.load(open(cache_file, 'rb'))
else:
self.cache = {'ada': {}, 'create': {}}
pickle.dump(self.cache, open(cache_file, 'wb'))
def get_ada_embedding(self, text):
if text not in self.cache['ada']:
self.cache['ada'][text] = self.ai_service.get_ada_embedding(text)
pickle.dump(self.cache, open(self.cache_file, 'wb'))
return self.cache['ada'][text]
def create(self, prompt, max_tokens=100, temperature=0.5):
key = (prompt, max_tokens, temperature)
if key not in self.cache['create']:
self.cache['create'][key] = self.ai_service.create(prompt, max_tokens, temperature)
pickle.dump(self.cache, open(self.cache_file, 'wb'))
return self.cache['create'][key]
class PineconeService:
def __init__(self, api_key, environment, table_name, dimension, metric, pod_type):
self.table_name = table_name
pinecone.init(api_key=api_key, environment=environment)
if table_name not in pinecone.list_indexes():
pinecone.create_index(table_name, dimension=dimension, metric=metric, pod_type=pod_type)
self.index = pinecone.Index(table_name)
def query(self, query_embedding, top_k):
results = self.index.query(query_embedding, top_k=top_k, include_metadata=True)
sorted_results = sorted(results.matches, key=lambda x: x.score, reverse=True)
return [Task(**item.metadata) for item in sorted_results]
def upsert(self, task):
self.index.upsert([(task.id, task.vector, task.__dict__)])
class LanceService:
def __init__(self, table_name, dimension):
self.db = lancedb.connect('.')
schema = pa.schema(
[
pa.field('id', pa.int32()),
pa.field('vector', pa.list_(pa.float32(), dimension)),
pa.field('name', pa.string()),
pa.field('result', pa.string()), # TODO There is a fixed schema but we keep converting
]
)
data = [{'id': 0, 'vector': [0.0] * dimension, 'name': 'asd', 'result': 'asd'}]
self.table = self.db.create_table(table_name, mode='overwrite', data=data, schema=schema)
def query(self, query_embedding, top_k):
result = self.table.search(query_embedding).limit(top_k).to_df().drop(columns=['score'])
return [Task(**v) for v in result.to_dict(orient="records")]
def upsert(self, task):
self.table.add(pd.DataFrame([task.__dict__]))
class BabyAGI:
def __init__(self, objective, ai_service, vector_service):
self.ai_service = ai_service
self.vector_service = vector_service
self.objective = objective
self.objective_embedding = self.ai_service.get_ada_embedding(self.objective)
self.task_list = deque([])
def add_task(self, task):
if task.id is None:
task.id = max([t.id for t in self.task_list], default=0) + 1
self.task_list.append(task)
def task_creation_agent(self, task):
prompt = TASK_CREATION_PROMPT.format(
objective=self.objective,
result=task.result,
task_description=task.name,
task_list=', '.join([t.name for t in self.task_list]),
)
return [{'task_name': task_name} for task_name in self.ai_service.create(prompt).split('\n')]
def prioritization_agent(self, this_task_id):
def to_task(value):
parts = value.strip().split('.', 1)
if len(parts) != 2:
return None
return Task(id=int(parts[0].strip()), name=parts[1].strip())
prompt = PRIORITIZATION_PROMPT.format(
task_names=', '.join([t.name for t in self.task_list]),
objective=self.objective,
next_task_id=int(this_task_id) + 1,
)
new_tasks = self.ai_service.create(prompt, max_tokens=1000)
self.task_list = deque([to_task(v) for v in new_tasks.split('\n') if to_task(v) is not None])
def run(self, first_task):
self.add_task(Task(name=first_task))
for _ in range(4):
if self.task_list:
context = self.vector_service.query(self.objective_embedding, 5)
task = self.task_list.popleft()
task.result = self.ai_service.create(
prompt=EXECUTION_PROMPT.format(objective=self.objective, task=task),
max_tokens=2000,
temperature=0.7,
)
task.vector = self.ai_service.get_ada_embedding(task.result)
self.vector_service.upsert(task)
new_tasks = self.task_creation_agent(task)
task_id_counter = 1
for new_task in new_tasks:
task_id_counter += 1
new_task.update({'task_id': task_id_counter})
self.add_task(Task(id=new_task['task_id'], name=new_task['task_name']))
self.prioritization_agent(task.id)
def main():
load_dotenv()
baby_agi = BabyAGI(
objective='Solve world hunger.',
ai_service=TestAIService(
ai_service=OpenAIService(api_key=os.getenv('OPENAI_API_KEY')),
cache_file='babyagi_cache.pkl',
),
vector_service=LanceService(
table_name='test-table',
dimension=1536,
)
# vector_service=PineconeService(
# api_key=os.getenv('PINECONE_API_KEY'),
# environment=os.getenv('PINECONE_ENVIRONMENT'),
# table_name='test-table',
# dimension=1536,
# metric='cosine',
# pod_type='p1',
# ),
)
baby_agi.run(first_task='Develop a task list.')
if __name__ == '__main__':
typer.run(main)
| [
"lancedb.connect"
] | [((7282, 7295), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (7293, 7295), False, 'from dotenv import load_dotenv\n'), ((8026, 8041), 'typer.run', 'typer.run', (['main'], {}), '(main)\n', (8035, 8041), False, 'import typer\n'), ((2219, 2245), 'os.path.isfile', 'os.path.isfile', (['cache_file'], {}), '(cache_file)\n', (2233, 2245), False, 'import os\n'), ((3212, 3267), 'pinecone.init', 'pinecone.init', ([], {'api_key': 'api_key', 'environment': 'environment'}), '(api_key=api_key, environment=environment)\n', (3225, 3267), False, 'import pinecone\n'), ((3444, 3470), 'pinecone.Index', 'pinecone.Index', (['table_name'], {}), '(table_name)\n', (3458, 3470), False, 'import pinecone\n'), ((3940, 3960), 'lancedb.connect', 'lancedb.connect', (['"""."""'], {}), "('.')\n", (3955, 3960), False, 'import lancedb\n'), ((5081, 5090), 'collections.deque', 'deque', (['[]'], {}), '([])\n', (5086, 5090), False, 'from collections import deque\n'), ((3297, 3320), 'pinecone.list_indexes', 'pinecone.list_indexes', ([], {}), '()\n', (3318, 3320), False, 'import pinecone\n'), ((3334, 3426), 'pinecone.create_index', 'pinecone.create_index', (['table_name'], {'dimension': 'dimension', 'metric': 'metric', 'pod_type': 'pod_type'}), '(table_name, dimension=dimension, metric=metric,\n pod_type=pod_type)\n', (3355, 3426), False, 'import pinecone\n'), ((4743, 4772), 'pandas.DataFrame', 'pd.DataFrame', (['[task.__dict__]'], {}), '([task.__dict__])\n', (4755, 4772), True, 'import pandas as pd\n'), ((4034, 4044), 'pyarrow.int32', 'pa.int32', ([], {}), '()\n', (4042, 4044), True, 'import pyarrow as pa\n'), ((4151, 4162), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (4160, 4162), True, 'import pyarrow as pa\n'), ((4200, 4211), 'pyarrow.string', 'pa.string', ([], {}), '()\n', (4209, 4211), True, 'import pyarrow as pa\n'), ((4091, 4103), 'pyarrow.float32', 'pa.float32', ([], {}), '()\n', (4101, 4103), True, 'import pyarrow as pa\n'), ((1711, 1883), 'openai.Completion.create', 'openai.Completion.create', ([], {'engine': '"""text-davinci-003"""', 'prompt': 'prompt', 'temperature': 'temperature', 'max_tokens': 'max_tokens', 'top_p': '(1)', 'frequency_penalty': '(0)', 'presence_penalty': '(0)'}), "(engine='text-davinci-003', prompt=prompt,\n temperature=temperature, max_tokens=max_tokens, top_p=1,\n frequency_penalty=0, presence_penalty=0)\n", (1735, 1883), False, 'import openai\n'), ((7440, 7467), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (7449, 7467), False, 'import os\n')] |
import json
from generate_data import *
from create_embeddings import *
import lancedb
uri = "./sample-lancedb"
db = lancedb.connect(uri)
text_table = "table_from_df_text"
img_table = "table_from_df_images"
tbl_txt = db.open_table(text_table)
tbl_img = db.open_table(img_table)
with open('./test_data.json') as f:
test_user_scripts = json.loads(f.read())
customers = list(test_user_scripts.keys())
customer_id = 0 # change this to test for different customers
# Format user chat history
def build_customer_chat_history(customer_id):
outstring=""
for q,a in test_user_scripts[customers[customer_id]].items():
outstring+=f"Question- {q} : User Answer: {a}"
return outstring
# this function reformats the user inputs to a json structured output very similar to the one used to create embeddings
def get_reformatted_output(user_prompt):
response = client.chat.completions.create(
model="gpt-4-turbo-preview",
response_format={ "type": "json_object" },
messages=[
{"role": "system", "content": "You are a helpful assistant with deep expertise in real estate."},
{"role": "user", "content": user_prompt}
]
)
listings = json.loads(response.choices[0].message.content)["listings"]
# print(listings)
return listings
def format_response(response):
out_string=""
for item,val in response.items():
if val != 'None':
out_string+=f"{item}: {val} "
return out_string
def get_user_preference(customer_id, img_path=None):
# if user provides an image as reference, we shall also use that. The assumption is that the image has been
# loaded and placed in a path the application can access
image = img_path
# if img_path:
# try:
# image = Image.open(image_path)
# except:
# pass
chat_history = build_customer_chat_history(customer_id)
user_prompt= f"""
Please only use the customer chat history given below to create a desired listing for them.
Use the example given below and format the results in json format.
All the results should be saved inside a key called listings.
Each result should have the following keys: Neighborhood, Price, Bedrooms, Bathrooms, House Size, Description, Neighborhood Description.
Use only information from the chat history. If any of the fields are unavailable,list them as None.
Customer Chat History: {chat_history}
Example:{example_listing}
"""
response = get_reformatted_output(user_prompt)[0]
formatted_response = format_response(response)
return formatted_response, image
def get_embeddings_user_prefs(resp):
text_resp, img_resp = resp[0],resp[1]
text_embs = get_embedding(text_resp)
img_embs = None
if img_resp:
try:
img_embs = create_clip_image_embeddings(img_resp, model_name)
except:
pass
return text_embs,img_embs
def search_tables(embeddings,num_responses=5):
text_embeddings = embeddings[0]
img_embeddings = embeddings[1]
df = tbl_txt.search(text_embeddings) \
.metric("cosine") \
.limit(num_responses) \
.to_pandas()
return df
resp = get_user_preference(customer_id)
embeddings = get_embeddings_user_prefs(resp)
print(search_tables(embeddings))
| [
"lancedb.connect"
] | [((119, 139), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (134, 139), False, 'import lancedb\n'), ((1192, 1239), 'json.loads', 'json.loads', (['response.choices[0].message.content'], {}), '(response.choices[0].message.content)\n', (1202, 1239), False, 'import json\n')] |
# Ultralytics YOLO 🚀, AGPL-3.0 license
from io import BytesIO
from pathlib import Path
from typing import Any, List, Tuple, Union
import cv2
import numpy as np
import torch
from matplotlib import pyplot as plt
from pandas import DataFrame
from PIL import Image
from tqdm import tqdm
from ultralytics.data.augment import Format
from ultralytics.data.dataset import YOLODataset
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.model import YOLO
from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks
from .utils import get_sim_index_schema, get_table_schema, plot_query_result, prompt_sql_query, sanitize_batch
class ExplorerDataset(YOLODataset):
def __init__(self, *args, data: dict = None, **kwargs) -> None:
super().__init__(*args, data=data, **kwargs)
def load_image(self, i: int) -> Union[Tuple[np.ndarray, Tuple[int, int], Tuple[int, int]], Tuple[None, None, None]]:
"""Loads 1 image from dataset index 'i' without any resize ops."""
im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
if im is None: # not cached in RAM
if fn.exists(): # load npy
im = np.load(fn)
else: # read image
im = cv2.imread(f) # BGR
if im is None:
raise FileNotFoundError(f"Image Not Found {f}")
h0, w0 = im.shape[:2] # orig hw
return im, (h0, w0), im.shape[:2]
return self.ims[i], self.im_hw0[i], self.im_hw[i]
def build_transforms(self, hyp: IterableSimpleNamespace = None):
"""Creates transforms for dataset images without resizing."""
return Format(
bbox_format="xyxy",
normalize=False,
return_mask=self.use_segments,
return_keypoint=self.use_keypoints,
batch_idx=True,
mask_ratio=hyp.mask_ratio,
mask_overlap=hyp.overlap_mask,
)
class Explorer:
def __init__(
self, data: Union[str, Path] = "coco128.yaml", model: str = "yolov8n.pt", uri: str = "~/ultralytics/explorer"
) -> None:
checks.check_requirements(["lancedb>=0.4.3", "duckdb"])
import lancedb
self.connection = lancedb.connect(uri)
self.table_name = Path(data).name.lower() + "_" + model.lower()
self.sim_idx_base_name = (
f"{self.table_name}_sim_idx".lower()
) # Use this name and append thres and top_k to reuse the table
self.model = YOLO(model)
self.data = data # None
self.choice_set = None
self.table = None
self.progress = 0
def create_embeddings_table(self, force: bool = False, split: str = "train") -> None:
"""
Create LanceDB table containing the embeddings of the images in the dataset. The table will be reused if it
already exists. Pass force=True to overwrite the existing table.
Args:
force (bool): Whether to overwrite the existing table or not. Defaults to False.
split (str): Split of the dataset to use. Defaults to 'train'.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
```
"""
if self.table is not None and not force:
LOGGER.info("Table already exists. Reusing it. Pass force=True to overwrite it.")
return
if self.table_name in self.connection.table_names() and not force:
LOGGER.info(f"Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.")
self.table = self.connection.open_table(self.table_name)
self.progress = 1
return
if self.data is None:
raise ValueError("Data must be provided to create embeddings table")
data_info = check_det_dataset(self.data)
if split not in data_info:
raise ValueError(
f"Split {split} is not found in the dataset. Available keys in the dataset are {list(data_info.keys())}"
)
choice_set = data_info[split]
choice_set = choice_set if isinstance(choice_set, list) else [choice_set]
self.choice_set = choice_set
dataset = ExplorerDataset(img_path=choice_set, data=data_info, augment=False, cache=False, task=self.model.task)
# Create the table schema
batch = dataset[0]
vector_size = self.model.embed(batch["im_file"], verbose=False)[0].shape[0]
table = self.connection.create_table(self.table_name, schema=get_table_schema(vector_size), mode="overwrite")
table.add(
self._yield_batches(
dataset,
data_info,
self.model,
exclude_keys=["img", "ratio_pad", "resized_shape", "ori_shape", "batch_idx"],
)
)
self.table = table
def _yield_batches(self, dataset: ExplorerDataset, data_info: dict, model: YOLO, exclude_keys: List[str]):
"""Generates batches of data for embedding, excluding specified keys."""
for i in tqdm(range(len(dataset))):
self.progress = float(i + 1) / len(dataset)
batch = dataset[i]
for k in exclude_keys:
batch.pop(k, None)
batch = sanitize_batch(batch, data_info)
batch["vector"] = model.embed(batch["im_file"], verbose=False)[0].detach().tolist()
yield [batch]
def query(
self, imgs: Union[str, np.ndarray, List[str], List[np.ndarray]] = None, limit: int = 25
) -> Any: # pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
imgs (str or list): Path to the image or a list of paths to the images.
limit (int): Number of results to return.
Returns:
(pyarrow.Table): An arrow table containing the results. Supports converting to:
- pandas dataframe: `result.to_pandas()`
- dict of lists: `result.to_pydict()`
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.query(img='https://ultralytics.com/images/zidane.jpg')
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
if isinstance(imgs, str):
imgs = [imgs]
assert isinstance(imgs, list), f"img must be a string or a list of strings. Got {type(imgs)}"
embeds = self.model.embed(imgs)
# Get avg if multiple images are passed (len > 1)
embeds = torch.mean(torch.stack(embeds), 0).cpu().numpy() if len(embeds) > 1 else embeds[0].cpu().numpy()
return self.table.search(embeds).limit(limit).to_arrow()
def sql_query(
self, query: str, return_type: str = "pandas"
) -> Union[DataFrame, Any, None]: # pandas.dataframe or pyarrow.Table
"""
Run a SQL-Like query on the table. Utilizes LanceDB predicate pushdown.
Args:
query (str): SQL query to run.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pyarrow.Table): An arrow table containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.sql_query(query)
```
"""
assert return_type in [
"pandas",
"arrow",
], f"Return type should be either `pandas` or `arrow`, but got {return_type}"
import duckdb
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
# Note: using filter pushdown would be a better long term solution. Temporarily using duckdb for this.
table = self.table.to_arrow() # noqa NOTE: Don't comment this. This line is used by DuckDB
if not query.startswith("SELECT") and not query.startswith("WHERE"):
raise ValueError(
f"Query must start with SELECT or WHERE. You can either pass the entire query or just the WHERE clause. found {query}"
)
if query.startswith("WHERE"):
query = f"SELECT * FROM 'table' {query}"
LOGGER.info(f"Running query: {query}")
rs = duckdb.sql(query)
if return_type == "pandas":
return rs.df()
elif return_type == "arrow":
return rs.arrow()
def plot_sql_query(self, query: str, labels: bool = True) -> Image.Image:
"""
Plot the results of a SQL-Like query on the table.
Args:
query (str): SQL query to run.
labels (bool): Whether to plot the labels or not.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
query = "SELECT * FROM 'table' WHERE labels LIKE '%person%'"
result = exp.plot_sql_query(query)
```
"""
result = self.sql_query(query, return_type="arrow")
if len(result) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(result, plot_labels=labels)
return Image.fromarray(img)
def get_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
return_type: str = "pandas",
) -> Union[DataFrame, Any]: # pandas.dataframe or pyarrow.Table
"""
Query the table for similar images. Accepts a single image or a list of images.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
limit (int): Number of results to return. Defaults to 25.
return_type (str): Type of the result to return. Can be either 'pandas' or 'arrow'. Defaults to 'pandas'.
Returns:
(pandas.DataFrame): A dataframe containing the results.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.get_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
assert return_type in [
"pandas",
"arrow",
], f"Return type should be either `pandas` or `arrow`, but got {return_type}"
img = self._check_imgs_or_idxs(img, idx)
similar = self.query(img, limit=limit)
if return_type == "pandas":
return similar.to_pandas()
elif return_type == "arrow":
return similar
def plot_similar(
self,
img: Union[str, np.ndarray, List[str], List[np.ndarray]] = None,
idx: Union[int, List[int]] = None,
limit: int = 25,
labels: bool = True,
) -> Image.Image:
"""
Plot the similar images. Accepts images or indexes.
Args:
img (str or list): Path to the image or a list of paths to the images.
idx (int or list): Index of the image in the table or a list of indexes.
labels (bool): Whether to plot the labels or not.
limit (int): Number of results to return. Defaults to 25.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similar = exp.plot_similar(img='https://ultralytics.com/images/zidane.jpg')
```
"""
similar = self.get_similar(img, idx, limit, return_type="arrow")
if len(similar) == 0:
LOGGER.info("No results found.")
return None
img = plot_query_result(similar, plot_labels=labels)
return Image.fromarray(img)
def similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> DataFrame:
"""
Calculate the similarity index of all the images in the table. Here, the index will contain the data points that
are max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of the closest data points to consider when counting. Used to apply limit when running
vector search. Defaults: None.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(pandas.DataFrame): A dataframe containing the similarity index. Each row corresponds to an image, and columns
include indices of similar images and their respective distances.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
sim_idx = exp.similarity_index()
```
"""
if self.table is None:
raise ValueError("Table is not created. Please create the table first.")
sim_idx_table_name = f"{self.sim_idx_base_name}_thres_{max_dist}_top_{top_k}".lower()
if sim_idx_table_name in self.connection.table_names() and not force:
LOGGER.info("Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.")
return self.connection.open_table(sim_idx_table_name).to_pandas()
if top_k and not (1.0 >= top_k >= 0.0):
raise ValueError(f"top_k must be between 0.0 and 1.0. Got {top_k}")
if max_dist < 0.0:
raise ValueError(f"max_dist must be greater than 0. Got {max_dist}")
top_k = int(top_k * len(self.table)) if top_k else len(self.table)
top_k = max(top_k, 1)
features = self.table.to_lance().to_table(columns=["vector", "im_file"]).to_pydict()
im_files = features["im_file"]
embeddings = features["vector"]
sim_table = self.connection.create_table(sim_idx_table_name, schema=get_sim_index_schema(), mode="overwrite")
def _yield_sim_idx():
"""Generates a dataframe with similarity indices and distances for images."""
for i in tqdm(range(len(embeddings))):
sim_idx = self.table.search(embeddings[i]).limit(top_k).to_pandas().query(f"_distance <= {max_dist}")
yield [
{
"idx": i,
"im_file": im_files[i],
"count": len(sim_idx),
"sim_im_files": sim_idx["im_file"].tolist(),
}
]
sim_table.add(_yield_sim_idx())
self.sim_index = sim_table
return sim_table.to_pandas()
def plot_similarity_index(self, max_dist: float = 0.2, top_k: float = None, force: bool = False) -> Image:
"""
Plot the similarity index of all the images in the table. Here, the index will contain the data points that are
max_dist or closer to the image in the embedding space at a given index.
Args:
max_dist (float): maximum L2 distance between the embeddings to consider. Defaults to 0.2.
top_k (float): Percentage of closest data points to consider when counting. Used to apply limit when
running vector search. Defaults to 0.01.
force (bool): Whether to overwrite the existing similarity index or not. Defaults to True.
Returns:
(PIL.Image): Image containing the plot.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
similarity_idx_plot = exp.plot_similarity_index()
similarity_idx_plot.show() # view image preview
similarity_idx_plot.save('path/to/save/similarity_index_plot.png') # save contents to file
```
"""
sim_idx = self.similarity_index(max_dist=max_dist, top_k=top_k, force=force)
sim_count = sim_idx["count"].tolist()
sim_count = np.array(sim_count)
indices = np.arange(len(sim_count))
# Create the bar plot
plt.bar(indices, sim_count)
# Customize the plot (optional)
plt.xlabel("data idx")
plt.ylabel("Count")
plt.title("Similarity Count")
buffer = BytesIO()
plt.savefig(buffer, format="png")
buffer.seek(0)
# Use Pillow to open the image from the buffer
return Image.fromarray(np.array(Image.open(buffer)))
def _check_imgs_or_idxs(
self, img: Union[str, np.ndarray, List[str], List[np.ndarray], None], idx: Union[None, int, List[int]]
) -> List[np.ndarray]:
if img is None and idx is None:
raise ValueError("Either img or idx must be provided.")
if img is not None and idx is not None:
raise ValueError("Only one of img or idx must be provided.")
if idx is not None:
idx = idx if isinstance(idx, list) else [idx]
img = self.table.to_lance().take(idx, columns=["im_file"]).to_pydict()["im_file"]
return img if isinstance(img, list) else [img]
def ask_ai(self, query):
"""
Ask AI a question.
Args:
query (str): Question to ask.
Returns:
(pandas.DataFrame): A dataframe containing filtered results to the SQL query.
Example:
```python
exp = Explorer()
exp.create_embeddings_table()
answer = exp.ask_ai('Show images with 1 person and 2 dogs')
```
"""
result = prompt_sql_query(query)
try:
df = self.sql_query(result)
except Exception as e:
LOGGER.error("AI generated query is not valid. Please try again with a different prompt")
LOGGER.error(e)
return None
return df
def visualize(self, result):
"""
Visualize the results of a query. TODO.
Args:
result (pyarrow.Table): Table containing the results of a query.
"""
pass
def generate_report(self, result):
"""
Generate a report of the dataset.
TODO
"""
pass
| [
"lancedb.connect"
] | [((1681, 1874), 'ultralytics.data.augment.Format', 'Format', ([], {'bbox_format': '"""xyxy"""', 'normalize': '(False)', 'return_mask': 'self.use_segments', 'return_keypoint': 'self.use_keypoints', 'batch_idx': '(True)', 'mask_ratio': 'hyp.mask_ratio', 'mask_overlap': 'hyp.overlap_mask'}), "(bbox_format='xyxy', normalize=False, return_mask=self.use_segments,\n return_keypoint=self.use_keypoints, batch_idx=True, mask_ratio=hyp.\n mask_ratio, mask_overlap=hyp.overlap_mask)\n", (1687, 1874), False, 'from ultralytics.data.augment import Format\n'), ((2138, 2193), 'ultralytics.utils.checks.check_requirements', 'checks.check_requirements', (["['lancedb>=0.4.3', 'duckdb']"], {}), "(['lancedb>=0.4.3', 'duckdb'])\n", (2163, 2193), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2244, 2264), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2259, 2264), False, 'import lancedb\n'), ((2515, 2526), 'ultralytics.models.yolo.model.YOLO', 'YOLO', (['model'], {}), '(model)\n', (2519, 2526), False, 'from ultralytics.models.yolo.model import YOLO\n'), ((3858, 3886), 'ultralytics.data.utils.check_det_dataset', 'check_det_dataset', (['self.data'], {}), '(self.data)\n', (3875, 3886), False, 'from ultralytics.data.utils import check_det_dataset\n'), ((8493, 8531), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Running query: {query}"""'], {}), "(f'Running query: {query}')\n", (8504, 8531), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((8546, 8563), 'duckdb.sql', 'duckdb.sql', (['query'], {}), '(query)\n', (8556, 8563), False, 'import duckdb\n'), ((9525, 9545), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (9540, 9545), False, 'from PIL import Image\n'), ((12170, 12190), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (12185, 12190), False, 'from PIL import Image\n'), ((16442, 16461), 'numpy.array', 'np.array', (['sim_count'], {}), '(sim_count)\n', (16450, 16461), True, 'import numpy as np\n'), ((16546, 16573), 'matplotlib.pyplot.bar', 'plt.bar', (['indices', 'sim_count'], {}), '(indices, sim_count)\n', (16553, 16573), True, 'from matplotlib import pyplot as plt\n'), ((16623, 16645), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""data idx"""'], {}), "('data idx')\n", (16633, 16645), True, 'from matplotlib import pyplot as plt\n'), ((16654, 16673), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Count"""'], {}), "('Count')\n", (16664, 16673), True, 'from matplotlib import pyplot as plt\n'), ((16682, 16711), 'matplotlib.pyplot.title', 'plt.title', (['"""Similarity Count"""'], {}), "('Similarity Count')\n", (16691, 16711), True, 'from matplotlib import pyplot as plt\n'), ((16729, 16738), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (16736, 16738), False, 'from io import BytesIO\n'), ((16747, 16780), 'matplotlib.pyplot.savefig', 'plt.savefig', (['buffer'], {'format': '"""png"""'}), "(buffer, format='png')\n", (16758, 16780), True, 'from matplotlib import pyplot as plt\n'), ((3319, 3405), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Table already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Table already exists. Reusing it. Pass force=True to overwrite it.')\n", (3330, 3405), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((3507, 3617), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['f"""Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n f'Table {self.table_name} already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (3518, 3617), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((9393, 9425), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (9404, 9425), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((12037, 12069), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""No results found."""'], {}), "('No results found.')\n", (12048, 12069), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((13647, 13750), 'ultralytics.utils.LOGGER.info', 'LOGGER.info', (['"""Similarity matrix already exists. Reusing it. Pass force=True to overwrite it."""'], {}), "(\n 'Similarity matrix already exists. Reusing it. Pass force=True to overwrite it.'\n )\n", (13658, 13750), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((1191, 1202), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (1198, 1202), True, 'import numpy as np\n'), ((1256, 1269), 'cv2.imread', 'cv2.imread', (['f'], {}), '(f)\n', (1266, 1269), False, 'import cv2\n'), ((16900, 16918), 'PIL.Image.open', 'Image.open', (['buffer'], {}), '(buffer)\n', (16910, 16918), False, 'from PIL import Image\n'), ((18136, 18235), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['"""AI generated query is not valid. Please try again with a different prompt"""'], {}), "(\n 'AI generated query is not valid. Please try again with a different prompt'\n )\n", (18148, 18235), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((18238, 18253), 'ultralytics.utils.LOGGER.error', 'LOGGER.error', (['e'], {}), '(e)\n', (18250, 18253), False, 'from ultralytics.utils import LOGGER, IterableSimpleNamespace, checks\n'), ((2291, 2301), 'pathlib.Path', 'Path', (['data'], {}), '(data)\n', (2295, 2301), False, 'from pathlib import Path\n'), ((6718, 6737), 'torch.stack', 'torch.stack', (['embeds'], {}), '(embeds)\n', (6729, 6737), False, 'import torch\n')] |
from PIL import Image
import streamlit as st
import openai
#exercise 11
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.chat_models import ChatOpenAI
#exercise 12
from langchain.memory import ConversationBufferWindowMemory
#exercise 13
from langchain.document_loaders import TextLoader,PyPDFLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import LanceDB
import lancedb
import os
import tempfile
# os.environ["OPENAI_API_KEY"] = st.secrets["openapi_key"]
# openai.api_key = st.secrets["openapi_key"]
#Global ex 13
cwd = os.getcwd()
WORKING_DIRECTORY = os.path.join(cwd, "database")
if not os.path.exists(WORKING_DIRECTORY):
os.makedirs(WORKING_DIRECTORY)
def ex11a(): # change in ex11a
# langchain prompt template
prompt = PromptTemplate(
input_variables=["subject", "topic"],
template="""Design a lesson plan on {subject} on the topic of {topic} for primary 1 students""",
)
# openai_api_key = st.secrets["openapi_key"]
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.9)
# creating a LLM chain with the langchain call and prompt template
chain = LLMChain(llm=llm, prompt=prompt)
if st.button("Run my chain"):
input_prompt = prompt.format(subject="English", topic="Verbs")
# Showing what is sent to LLM Chain
st.write("Input prompt: ", input_prompt)
# Showing the output from LLM Chain
st.write(chain.run({"subject": "English", "topic": "Verbs"}))
def prompt_inputs_form(): #Using st.form, create the starting prompt to your prompt template, this is an expert on a topic that is talking to a user of a certain age
#langchain prompt template
with st.form("Prompt Template"):
occupation = st.text_input("Enter the occupation:")
topic = st.text_input("Enter the topic:")
age = st.text_input("Enter the age:")
# Every form must have a submit button.
submitted = st.form_submit_button("Submit")
#return a dictionary of the values
if submitted:
return {
'occupation': occupation,
'topic': topic,
'age': age
}
def ex11b():
# create your template
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
# create a langchain function call to openai
llm = ChatOpenAI(
model_name="gpt-3.5-turbo",
temperature=0.9,
)
# create a LLM chain with the langchain call and prompt template
chain = LLMChain(llm=llm, prompt=prompt_template)
# call the prompt_inputs_form()
dict_inputs = prompt_inputs_form()
if dict_inputs:
st.write(chain.run(dict_inputs))
def ex12():
memory = ConversationBufferWindowMemory(k=3)
memory.save_context({"input": "hi"}, {"output": "whats up?"})
memory.save_context({"input": "not much"}, {"output": "what can I help you with?"})
st.write(memory.load_memory_variables({}))
memory = ConversationBufferWindowMemory( k=3, return_messages=True)
memory.save_context({"input": "hi"}, {"output": "whats up?"})
memory.save_context({"input": "not much"}, {"output": "what can I help you with?"})
st.write(memory.load_memory_variables({}))
#exercise 13 - loading
def upload_file_streamlit():
def get_file_extension(file_name):
return os.path.splitext(file_name)[1]
st.subheader("Upload your docs")
# Streamlit file uploader to accept file input
uploaded_file = st.file_uploader("Choose a file", type=["docx", "txt", "pdf"])
if uploaded_file:
# Reading file content
file_content = uploaded_file.read()
# Determine the suffix based on uploaded file's name
file_suffix = get_file_extension(uploaded_file.name)
# Saving the uploaded file temporarily to process it
with tempfile.NamedTemporaryFile(delete=False, suffix=file_suffix) as temp_file:
temp_file.write(file_content)
temp_file.flush() # Ensure the data is written to the file
temp_file_path = temp_file.name
return temp_file_path
#exercise 13 - split and chunk, embeddings and storing in vectorstores for reference
def vectorstore_creator():
# WORKING_DIRECTORY set above in the main.py
# Process the temporary file using UnstructuredFileLoader (or any other method you need)
embeddings = OpenAIEmbeddings()
db = lancedb.connect(WORKING_DIRECTORY)
table = db.create_table(
"my_table",
data=[
{
"vector": embeddings.embed_query("Query unsuccessful"),
"text": "Query unsuccessful",
"id": "1",
}
],
mode="overwrite",
)
# st.write(temp_file_path)
temp_file_path = upload_file_streamlit()
if temp_file_path:
loader = PyPDFLoader(temp_file_path)
documents = loader.load_and_split()
db = LanceDB.from_documents(documents, embeddings, connection=table)
return db
def ex13():
if "vectorstore" not in st.session_state:
st.session_state.vectorstore = False
db = vectorstore_creator()
st.session_state.vectorstore = db
if st.session_state.vectorstore:
query = st.text_input("Enter a query")
if query:
st.session_state.vectorstore = db
docs = db.similarity_search(query)
st.write(docs[0].page_content)
def chat_completion_stream_prompt(prompt):
MODEL = "gpt-3.5-turbo" #consider changing this to session_state
response = openai.ChatCompletion.create(
model=MODEL,
messages=[
{"role": "system", "content": st.session_state.prompt_template},
{"role": "user", "content": prompt},
],
temperature= 0, # temperature
stream=True #stream option
)
return response
# save the vectorstore in st.session_state
# add semantic search prompt into memory prompt
# integrate back into your chatbot
def ex14_basebot():
# Prompt_template form from ex11
prompt_template = PromptTemplate(
input_variables=["occupation", "topic", "age"],
template="""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information
to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up""",
)
dict_inputs = prompt_inputs_form()
if dict_inputs:
input_prompt = prompt_template.format(
occupation=dict_inputs["occupation"],
topic=dict_inputs["topic"],
age=dict_inputs["age"],
)
st.session_state.input_prompt = input_prompt
if "input_prompt" not in st.session_state:
st.session_state.input_prompt = "Speak like Yoda from Star Wars"
if "memory" not in st.session_state:
st.session_state.memory = ConversationBufferWindowMemory(k=5)
# step 1 save the memory from your chatbot
# step 2 integrate the memory in the prompt_template (st.session_state.prompt_template) show a hint
memory_data = st.session_state.memory.load_memory_variables({})
st.write(memory_data)
st.session_state.prompt_template = f"""
st.session_state.input_prompt: {st.session_state.input_prompt}
This is the last conversation history
{memory_data}
"""
st.write("new prompt template: ", st.session_state.prompt_template)
st.session_state.vectorstore = vectorstore_creator()
# Initialize chat history
if "msg" not in st.session_state:
st.session_state.msg = []
# Showing Chat history
for message in st.session_state.msg:
with st.chat_message(message["role"]):
st.markdown(message["content"])
try:
#
if prompt := st.chat_input("What is up?"):
# query information
if st.session_state.vectorstore:
docs = st.session_state.vectorstore.similarity_search(prompt)
docs = docs[0].page_content
# add your query prompt
vs_prompt = f"""You should reference this search result to help your answer,
{docs}
if the search result does not anwer the query, please say you are unable to answer, do not make up an answer"""
else:
vs_prompt = ""
# add query prompt to your memory prompt and send it to LLM
st.session_state.prompt_template = (
st.session_state.prompt_template + vs_prompt
)
# set user prompt in chat history
st.session_state.msg.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
# streaming function
for response in chat_completion_stream_prompt(prompt):
full_response += response.choices[0].delta.get("content", "")
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.msg.append({"role": "assistant", "content": full_response})
st.session_state.memory.save_context(
{"input": prompt}, {"output": full_response}
)
except Exception as e:
st.error(e) | [
"lancedb.connect"
] | [((649, 660), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (658, 660), False, 'import os\n'), ((681, 710), 'os.path.join', 'os.path.join', (['cwd', '"""database"""'], {}), "(cwd, 'database')\n", (693, 710), False, 'import os\n'), ((719, 752), 'os.path.exists', 'os.path.exists', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (733, 752), False, 'import os\n'), ((755, 785), 'os.makedirs', 'os.makedirs', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (766, 785), False, 'import os\n'), ((859, 1014), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['subject', 'topic']", 'template': '"""Design a lesson plan on {subject} on the topic of {topic} for primary 1 students"""'}), "(input_variables=['subject', 'topic'], template=\n 'Design a lesson plan on {subject} on the topic of {topic} for primary 1 students'\n )\n", (873, 1014), False, 'from langchain.prompts import PromptTemplate\n'), ((1071, 1126), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0.9)'}), "(model_name='gpt-3.5-turbo', temperature=0.9)\n", (1081, 1126), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1205, 1237), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (1213, 1237), False, 'from langchain.chains import LLMChain\n'), ((1242, 1267), 'streamlit.button', 'st.button', (['"""Run my chain"""'], {}), "('Run my chain')\n", (1251, 1267), True, 'import streamlit as st\n'), ((2158, 2497), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['occupation', 'topic', 'age']", 'template': '"""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""'}), "(input_variables=['occupation', 'topic', 'age'], template=\n 'Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information to the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up'\n )\n", (2172, 2497), False, 'from langchain.prompts import PromptTemplate\n'), ((2553, 2608), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0.9)'}), "(model_name='gpt-3.5-turbo', temperature=0.9)\n", (2563, 2608), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2692, 2733), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt_template'}), '(llm=llm, prompt=prompt_template)\n', (2700, 2733), False, 'from langchain.chains import LLMChain\n'), ((2880, 2915), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'k': '(3)'}), '(k=3)\n', (2910, 2915), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((3123, 3180), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'k': '(3)', 'return_messages': '(True)'}), '(k=3, return_messages=True)\n', (3153, 3180), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((3506, 3538), 'streamlit.subheader', 'st.subheader', (['"""Upload your docs"""'], {}), "('Upload your docs')\n", (3518, 3538), True, 'import streamlit as st\n'), ((3605, 3667), 'streamlit.file_uploader', 'st.file_uploader', (['"""Choose a file"""'], {'type': "['docx', 'txt', 'pdf']"}), "('Choose a file', type=['docx', 'txt', 'pdf'])\n", (3621, 3667), True, 'import streamlit as st\n'), ((4420, 4438), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (4436, 4438), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((4445, 4479), 'lancedb.connect', 'lancedb.connect', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (4460, 4479), False, 'import lancedb\n'), ((5402, 5592), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'MODEL', 'messages': "[{'role': 'system', 'content': st.session_state.prompt_template}, {'role':\n 'user', 'content': prompt}]", 'temperature': '(0)', 'stream': '(True)'}), "(model=MODEL, messages=[{'role': 'system',\n 'content': st.session_state.prompt_template}, {'role': 'user',\n 'content': prompt}], temperature=0, stream=True)\n", (5430, 5592), False, 'import openai\n'), ((5855, 6204), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['occupation', 'topic', 'age']", 'template': '"""Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""'}), '(input_variables=[\'occupation\', \'topic\', \'age\'], template=\n """Imagine you are a {occupation} who is an expert on the topic of {topic} , you are going to help , teach and provide information\n\t\t\t\t\t\tto the person who is {age} years old, if you do not not know the answer, you must tell the person , do not make any answer up"""\n )\n', (5869, 6204), False, 'from langchain.prompts import PromptTemplate\n'), ((6823, 6872), 'streamlit.session_state.memory.load_memory_variables', 'st.session_state.memory.load_memory_variables', (['{}'], {}), '({})\n', (6868, 6872), True, 'import streamlit as st\n'), ((6874, 6895), 'streamlit.write', 'st.write', (['memory_data'], {}), '(memory_data)\n', (6882, 6895), True, 'import streamlit as st\n'), ((7059, 7126), 'streamlit.write', 'st.write', (['"""new prompt template: """', 'st.session_state.prompt_template'], {}), "('new prompt template: ', st.session_state.prompt_template)\n", (7067, 7126), True, 'import streamlit as st\n'), ((1374, 1414), 'streamlit.write', 'st.write', (['"""Input prompt: """', 'input_prompt'], {}), "('Input prompt: ', input_prompt)\n", (1382, 1414), True, 'import streamlit as st\n'), ((1719, 1745), 'streamlit.form', 'st.form', (['"""Prompt Template"""'], {}), "('Prompt Template')\n", (1726, 1745), True, 'import streamlit as st\n'), ((1762, 1800), 'streamlit.text_input', 'st.text_input', (['"""Enter the occupation:"""'], {}), "('Enter the occupation:')\n", (1775, 1800), True, 'import streamlit as st\n'), ((1811, 1844), 'streamlit.text_input', 'st.text_input', (['"""Enter the topic:"""'], {}), "('Enter the topic:')\n", (1824, 1844), True, 'import streamlit as st\n'), ((1853, 1884), 'streamlit.text_input', 'st.text_input', (['"""Enter the age:"""'], {}), "('Enter the age:')\n", (1866, 1884), True, 'import streamlit as st\n'), ((1941, 1972), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""Submit"""'], {}), "('Submit')\n", (1962, 1972), True, 'import streamlit as st\n'), ((4777, 4804), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['temp_file_path'], {}), '(temp_file_path)\n', (4788, 4804), False, 'from langchain.document_loaders import TextLoader, PyPDFLoader\n'), ((4850, 4913), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['documents', 'embeddings'], {'connection': 'table'}), '(documents, embeddings, connection=table)\n', (4872, 4913), False, 'from langchain.vectorstores import LanceDB\n'), ((5128, 5158), 'streamlit.text_input', 'st.text_input', (['"""Enter a query"""'], {}), "('Enter a query')\n", (5141, 5158), True, 'import streamlit as st\n'), ((6626, 6661), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'k': '(5)'}), '(k=5)\n', (6656, 6661), False, 'from langchain.memory import ConversationBufferWindowMemory\n'), ((3473, 3500), 'os.path.splitext', 'os.path.splitext', (['file_name'], {}), '(file_name)\n', (3489, 3500), False, 'import os\n'), ((3925, 3986), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {'delete': '(False)', 'suffix': 'file_suffix'}), '(delete=False, suffix=file_suffix)\n', (3952, 3986), False, 'import tempfile\n'), ((5249, 5279), 'streamlit.write', 'st.write', (['docs[0].page_content'], {}), '(docs[0].page_content)\n', (5257, 5279), True, 'import streamlit as st\n'), ((7343, 7375), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (7358, 7375), True, 'import streamlit as st\n'), ((7380, 7411), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (7391, 7411), True, 'import streamlit as st\n'), ((7437, 7465), 'streamlit.chat_input', 'st.chat_input', (['"""What is up?"""'], {}), "('What is up?')\n", (7450, 7465), True, 'import streamlit as st\n'), ((8093, 8157), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (8120, 8157), True, 'import streamlit as st\n'), ((8571, 8647), 'streamlit.session_state.msg.append', 'st.session_state.msg.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content': full_response})\n", (8598, 8647), True, 'import streamlit as st\n'), ((8651, 8737), 'streamlit.session_state.memory.save_context', 'st.session_state.memory.save_context', (["{'input': prompt}", "{'output': full_response}"], {}), "({'input': prompt}, {'output':\n full_response})\n", (8687, 8737), True, 'import streamlit as st\n'), ((8770, 8781), 'streamlit.error', 'st.error', (['e'], {}), '(e)\n', (8778, 8781), True, 'import streamlit as st\n'), ((7537, 7591), 'streamlit.session_state.vectorstore.similarity_search', 'st.session_state.vectorstore.similarity_search', (['prompt'], {}), '(prompt)\n', (7583, 7591), True, 'import streamlit as st\n'), ((8166, 8189), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (8181, 8189), True, 'import streamlit as st\n'), ((8195, 8214), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (8206, 8214), True, 'import streamlit as st\n'), ((8224, 8252), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (8239, 8252), True, 'import streamlit as st\n'), ((8280, 8290), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (8288, 8290), True, 'import streamlit as st\n')] |
from PIL import Image
import streamlit as st
import openai
#exercise 11
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
#exercise 12
from langchain.memory import ConversationBufferWindowMemory
#exercise 13
from langchain.document_loaders import TextLoader,PyPDFLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import LanceDB
import lancedb
import os
import tempfile
#exercise 15
import sqlite3
import pandas as pd
from datetime import datetime
#exercise 16
from langchain.agents import ConversationalChatAgent, AgentExecutor
from langchain.callbacks import StreamlitCallbackHandler
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.memory.chat_message_histories import StreamlitChatMessageHistory
from langchain.tools import DuckDuckGoSearchRun
#Exercise 17
from langchain.agents import tool
import json
# os.environ["OPENAI_API_KEY"] = st.secrets["openapi_key"]
# openai.api_key = st.secrets["openapi_key"]
#Global ex 13
cwd = os.getcwd()
WORKING_DIRECTORY = os.path.join(cwd, "database")
if not os.path.exists(WORKING_DIRECTORY):
os.makedirs(WORKING_DIRECTORY)
#ex15
DB_NAME = os.path.join(WORKING_DIRECTORY, "default_db")
def ex15_initialise():
# Create or check for the 'database' directory in the current working directory
# Set DB_NAME to be within the 'database' directory at the top of main.py
# Connect to the SQLite database
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
# Conversation data table
cursor.execute(
"""
CREATE TABLE IF NOT EXISTS data_table (
id INTEGER PRIMARY KEY,
date TEXT NOT NULL UNIQUE,
username TEXT NOT NULL,
chatbot_ans TEXT NOT NULL,
user_prompt TEXT NOT NULL,
tokens TEXT
)
"""
)
conn.commit()
conn.close()
def ex15_collect(username, chatbot_response, prompt):
# collect data from bot
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
now = datetime.now() # Using ISO format for date
tokens = len(chatbot_response) * 1.3
cursor.execute(
"""
INSERT INTO data_table (date, username,chatbot_ans, user_prompt, tokens)
VALUES (?, ?, ?, ?, ?)
""",
(now, username, chatbot_response, prompt, tokens),
)
conn.commit()
conn.close()
# implementing data collection and displaying
def ex15():
# initialise database first
ex15_initialise()
# collect some data
ex15_collect("yoda", "I am Yoda. The Force is strong with you", "Who are you?")
# display data
# Connect to the specified database
conn = sqlite3.connect(DB_NAME)
cursor = conn.cursor()
# Fetch all data from data_table
cursor.execute("SELECT * FROM data_table")
rows = cursor.fetchall()
column_names = [description[0] for description in cursor.description]
df = pd.DataFrame(rows, columns=column_names)
st.dataframe(df)
conn.close()
# smart agents accessing the internet for free
# https://github.com/langchain-ai/streamlit-agent/blob/main/streamlit_agent/search_and_chat.py
def ex16_agent_bot():
st.title("🦜 LangChain: Chat with internet search")
msgs = StreamlitChatMessageHistory()
memory = ConversationBufferMemory(
chat_memory=msgs,
return_messages=True,
memory_key="chat_history",
output_key="output",
)
if len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):
msgs.clear()
msgs.add_ai_message("How can I help you?")
st.session_state.steps = {}
avatars = {"human": "user", "ai": "assistant"}
for idx, msg in enumerate(msgs.messages):
with st.chat_message(avatars[msg.type]):
# Render intermediate steps if any were saved
for step in st.session_state.steps.get(str(idx), []):
if step[0].tool == "_Exception":
continue
with st.status(
f"**{step[0].tool}**: {step[0].tool_input}", state="complete"
):
st.write(step[0].log)
st.write(step[1])
st.write(msg.content)
if prompt := st.chat_input(placeholder="Enter a query on the Internet"):
st.chat_message("user").write(prompt)
llm = ChatOpenAI(
model_name="gpt-3.5-turbo", openai_api_key=openai.api_key, streaming=True
)
tools = [DuckDuckGoSearchRun(name="Search")]
chat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)
executor = AgentExecutor.from_agent_and_tools(
agent=chat_agent,
tools=tools,
memory=memory,
return_intermediate_steps=True,
handle_parsing_errors=True,
)
with st.chat_message("assistant"):
st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
response = executor(prompt, callbacks=[st_cb])
st.write(response["output"])
st.session_state.steps[str(len(msgs.messages) - 1)] = response[
"intermediate_steps"
]
def upload_file_streamlit():
def get_file_extension(file_name):
return os.path.splitext(file_name)[1]
st.subheader("Upload your docs")
# Streamlit file uploader to accept file input
uploaded_file = st.file_uploader("Choose a file", type=["docx", "txt", "pdf"])
if uploaded_file:
# Reading file content
file_content = uploaded_file.read()
# Determine the suffix based on uploaded file's name
file_suffix = get_file_extension(uploaded_file.name)
# Saving the uploaded file temporarily to process it
with tempfile.NamedTemporaryFile(delete=False, suffix=file_suffix) as temp_file:
temp_file.write(file_content)
temp_file.flush() # Ensure the data is written to the file
temp_file_path = temp_file.name
return temp_file_path
#exercise 13 - split and chunk, embeddings and storing in vectorstores for reference
def vectorstore_creator():
# WORKING_DIRECTORY set above in the main.py
# Process the temporary file using UnstructuredFileLoader (or any other method you need)
embeddings = OpenAIEmbeddings()
db = lancedb.connect(WORKING_DIRECTORY)
table = db.create_table(
"my_table",
data=[
{
"vector": embeddings.embed_query("Query unsuccessful"),
"text": "Query unsuccessful",
"id": "1",
}
],
mode="overwrite",
)
# st.write(temp_file_path)
temp_file_path = upload_file_streamlit()
if temp_file_path:
loader = PyPDFLoader(temp_file_path)
documents = loader.load_and_split()
db = LanceDB.from_documents(documents, embeddings, connection=table)
return db
# agents ,vectorstores, wiki
# https://python.langchain.com/docs/modules/agents/how_to/custom_agent_with_tool_retrieval
# note tool
@tool("Document search")
def document_search(query: str) -> str:
# this is the prompt to the tool itself
"Use this function first to search for documents pertaining to the query before going into the internet"
docs = st.session_state.vectorstore.similarity_search(query)
docs = docs[0].page_content
json_string = json.dumps(docs, ensure_ascii=False, indent=4)
return json_string
# combine vector store and internet search
def ex17_agent_bot():
st.title("🦜 LangChain: Chat with internet search")
st.session_state.vectorstore = vectorstore_creator()
msgs = StreamlitChatMessageHistory()
memory = ConversationBufferMemory(
chat_memory=msgs,
return_messages=True,
memory_key="chat_history",
output_key="output",
)
if len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):
msgs.clear()
msgs.add_ai_message("How can I help you?")
st.session_state.steps = {}
avatars = {"human": "user", "ai": "assistant"}
for idx, msg in enumerate(msgs.messages):
with st.chat_message(avatars[msg.type]):
# Render intermediate steps if any were saved
for step in st.session_state.steps.get(str(idx), []):
if step[0].tool == "_Exception":
continue
with st.status(
f"**{step[0].tool}**: {step[0].tool_input}", state="complete"
):
st.write(step[0].log)
st.write(step[1])
st.write(msg.content)
if prompt := st.chat_input(placeholder="Enter a query on the Internet"):
st.chat_message("user").write(prompt)
llm = ChatOpenAI(
model_name="gpt-3.5-turbo", openai_api_key=openai.api_key, streaming=True
)
tools = [document_search, DuckDuckGoSearchRun(name="Internet Search")]
chat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)
executor = AgentExecutor.from_agent_and_tools(
agent=chat_agent,
tools=tools,
memory=memory,
return_intermediate_steps=True,
handle_parsing_errors=True,
)
with st.chat_message("assistant"):
st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
response = executor(prompt, callbacks=[st_cb])
st.write(response["output"])
st.session_state.steps[str(len(msgs.messages) - 1)] = response[
"intermediate_steps"
]
| [
"lancedb.connect"
] | [((1106, 1117), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1115, 1117), False, 'import os\n'), ((1138, 1167), 'os.path.join', 'os.path.join', (['cwd', '"""database"""'], {}), "(cwd, 'database')\n", (1150, 1167), False, 'import os\n'), ((1259, 1304), 'os.path.join', 'os.path.join', (['WORKING_DIRECTORY', '"""default_db"""'], {}), "(WORKING_DIRECTORY, 'default_db')\n", (1271, 1304), False, 'import os\n'), ((6373, 6396), 'langchain.agents.tool', 'tool', (['"""Document search"""'], {}), "('Document search')\n", (6377, 6396), False, 'from langchain.agents import tool\n'), ((1176, 1209), 'os.path.exists', 'os.path.exists', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (1190, 1209), False, 'import os\n'), ((1212, 1242), 'os.makedirs', 'os.makedirs', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (1223, 1242), False, 'import os\n'), ((1527, 1551), 'sqlite3.connect', 'sqlite3.connect', (['DB_NAME'], {}), '(DB_NAME)\n', (1542, 1551), False, 'import sqlite3\n'), ((1957, 1981), 'sqlite3.connect', 'sqlite3.connect', (['DB_NAME'], {}), '(DB_NAME)\n', (1972, 1981), False, 'import sqlite3\n'), ((2013, 2027), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (2025, 2027), False, 'from datetime import datetime\n'), ((2579, 2603), 'sqlite3.connect', 'sqlite3.connect', (['DB_NAME'], {}), '(DB_NAME)\n', (2594, 2603), False, 'import sqlite3\n'), ((2810, 2850), 'pandas.DataFrame', 'pd.DataFrame', (['rows'], {'columns': 'column_names'}), '(rows, columns=column_names)\n', (2822, 2850), True, 'import pandas as pd\n'), ((2852, 2868), 'streamlit.dataframe', 'st.dataframe', (['df'], {}), '(df)\n', (2864, 2868), True, 'import streamlit as st\n'), ((3049, 3099), 'streamlit.title', 'st.title', (['"""🦜 LangChain: Chat with internet search"""'], {}), "('🦜 LangChain: Chat with internet search')\n", (3057, 3099), True, 'import streamlit as st\n'), ((3109, 3138), 'langchain.memory.chat_message_histories.StreamlitChatMessageHistory', 'StreamlitChatMessageHistory', ([], {}), '()\n', (3136, 3138), False, 'from langchain.memory.chat_message_histories import StreamlitChatMessageHistory\n'), ((3149, 3266), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'chat_memory': 'msgs', 'return_messages': '(True)', 'memory_key': '"""chat_history"""', 'output_key': '"""output"""'}), "(chat_memory=msgs, return_messages=True, memory_key\n ='chat_history', output_key='output')\n", (3173, 3266), False, 'from langchain.memory import ConversationBufferMemory\n'), ((4818, 4850), 'streamlit.subheader', 'st.subheader', (['"""Upload your docs"""'], {}), "('Upload your docs')\n", (4830, 4850), True, 'import streamlit as st\n'), ((4917, 4979), 'streamlit.file_uploader', 'st.file_uploader', (['"""Choose a file"""'], {'type': "['docx', 'txt', 'pdf']"}), "('Choose a file', type=['docx', 'txt', 'pdf'])\n", (4933, 4979), True, 'import streamlit as st\n'), ((5732, 5750), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (5748, 5750), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((5757, 5791), 'lancedb.connect', 'lancedb.connect', (['WORKING_DIRECTORY'], {}), '(WORKING_DIRECTORY)\n', (5772, 5791), False, 'import lancedb\n'), ((6592, 6645), 'streamlit.session_state.vectorstore.similarity_search', 'st.session_state.vectorstore.similarity_search', (['query'], {}), '(query)\n', (6638, 6645), True, 'import streamlit as st\n'), ((6690, 6736), 'json.dumps', 'json.dumps', (['docs'], {'ensure_ascii': '(False)', 'indent': '(4)'}), '(docs, ensure_ascii=False, indent=4)\n', (6700, 6736), False, 'import json\n'), ((6824, 6874), 'streamlit.title', 'st.title', (['"""🦜 LangChain: Chat with internet search"""'], {}), "('🦜 LangChain: Chat with internet search')\n", (6832, 6874), True, 'import streamlit as st\n'), ((6939, 6968), 'langchain.memory.chat_message_histories.StreamlitChatMessageHistory', 'StreamlitChatMessageHistory', ([], {}), '()\n', (6966, 6968), False, 'from langchain.memory.chat_message_histories import StreamlitChatMessageHistory\n'), ((6979, 7096), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'chat_memory': 'msgs', 'return_messages': '(True)', 'memory_key': '"""chat_history"""', 'output_key': '"""output"""'}), "(chat_memory=msgs, return_messages=True, memory_key\n ='chat_history', output_key='output')\n", (7003, 7096), False, 'from langchain.memory import ConversationBufferMemory\n'), ((3305, 3344), 'streamlit.sidebar.button', 'st.sidebar.button', (['"""Reset chat history"""'], {}), "('Reset chat history')\n", (3322, 3344), True, 'import streamlit as st\n'), ((3912, 3970), 'streamlit.chat_input', 'st.chat_input', ([], {'placeholder': '"""Enter a query on the Internet"""'}), "(placeholder='Enter a query on the Internet')\n", (3925, 3970), True, 'import streamlit as st\n'), ((4021, 4110), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'openai_api_key': 'openai.api_key', 'streaming': '(True)'}), "(model_name='gpt-3.5-turbo', openai_api_key=openai.api_key,\n streaming=True)\n", (4031, 4110), False, 'from langchain.chat_models import ChatOpenAI\n'), ((4176, 4240), 'langchain.agents.ConversationalChatAgent.from_llm_and_tools', 'ConversationalChatAgent.from_llm_and_tools', ([], {'llm': 'llm', 'tools': 'tools'}), '(llm=llm, tools=tools)\n', (4218, 4240), False, 'from langchain.agents import ConversationalChatAgent, AgentExecutor\n'), ((4254, 4399), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'chat_agent', 'tools': 'tools', 'memory': 'memory', 'return_intermediate_steps': '(True)', 'handle_parsing_errors': '(True)'}), '(agent=chat_agent, tools=tools, memory=\n memory, return_intermediate_steps=True, handle_parsing_errors=True)\n', (4288, 4399), False, 'from langchain.agents import ConversationalChatAgent, AgentExecutor\n'), ((6089, 6116), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['temp_file_path'], {}), '(temp_file_path)\n', (6100, 6116), False, 'from langchain.document_loaders import TextLoader, PyPDFLoader\n'), ((6162, 6225), 'langchain.vectorstores.LanceDB.from_documents', 'LanceDB.from_documents', (['documents', 'embeddings'], {'connection': 'table'}), '(documents, embeddings, connection=table)\n', (6184, 6225), False, 'from langchain.vectorstores import LanceDB\n'), ((7135, 7174), 'streamlit.sidebar.button', 'st.sidebar.button', (['"""Reset chat history"""'], {}), "('Reset chat history')\n", (7152, 7174), True, 'import streamlit as st\n'), ((7742, 7800), 'streamlit.chat_input', 'st.chat_input', ([], {'placeholder': '"""Enter a query on the Internet"""'}), "(placeholder='Enter a query on the Internet')\n", (7755, 7800), True, 'import streamlit as st\n'), ((7851, 7940), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'openai_api_key': 'openai.api_key', 'streaming': '(True)'}), "(model_name='gpt-3.5-turbo', openai_api_key=openai.api_key,\n streaming=True)\n", (7861, 7940), False, 'from langchain.chat_models import ChatOpenAI\n'), ((8032, 8096), 'langchain.agents.ConversationalChatAgent.from_llm_and_tools', 'ConversationalChatAgent.from_llm_and_tools', ([], {'llm': 'llm', 'tools': 'tools'}), '(llm=llm, tools=tools)\n', (8074, 8096), False, 'from langchain.agents import ConversationalChatAgent, AgentExecutor\n'), ((8110, 8255), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'chat_agent', 'tools': 'tools', 'memory': 'memory', 'return_intermediate_steps': '(True)', 'handle_parsing_errors': '(True)'}), '(agent=chat_agent, tools=tools, memory=\n memory, return_intermediate_steps=True, handle_parsing_errors=True)\n', (8144, 8255), False, 'from langchain.agents import ConversationalChatAgent, AgentExecutor\n'), ((3535, 3569), 'streamlit.chat_message', 'st.chat_message', (['avatars[msg.type]'], {}), '(avatars[msg.type])\n', (3550, 3569), True, 'import streamlit as st\n'), ((3875, 3896), 'streamlit.write', 'st.write', (['msg.content'], {}), '(msg.content)\n', (3883, 3896), True, 'import streamlit as st\n'), ((4125, 4159), 'langchain.tools.DuckDuckGoSearchRun', 'DuckDuckGoSearchRun', ([], {'name': '"""Search"""'}), "(name='Search')\n", (4144, 4159), False, 'from langchain.tools import DuckDuckGoSearchRun\n'), ((4422, 4450), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (4437, 4450), True, 'import streamlit as st\n'), ((4584, 4612), 'streamlit.write', 'st.write', (["response['output']"], {}), "(response['output'])\n", (4592, 4612), True, 'import streamlit as st\n'), ((4785, 4812), 'os.path.splitext', 'os.path.splitext', (['file_name'], {}), '(file_name)\n', (4801, 4812), False, 'import os\n'), ((5237, 5298), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {'delete': '(False)', 'suffix': 'file_suffix'}), '(delete=False, suffix=file_suffix)\n', (5264, 5298), False, 'import tempfile\n'), ((7365, 7399), 'streamlit.chat_message', 'st.chat_message', (['avatars[msg.type]'], {}), '(avatars[msg.type])\n', (7380, 7399), True, 'import streamlit as st\n'), ((7705, 7726), 'streamlit.write', 'st.write', (['msg.content'], {}), '(msg.content)\n', (7713, 7726), True, 'import streamlit as st\n'), ((7972, 8015), 'langchain.tools.DuckDuckGoSearchRun', 'DuckDuckGoSearchRun', ([], {'name': '"""Internet Search"""'}), "(name='Internet Search')\n", (7991, 8015), False, 'from langchain.tools import DuckDuckGoSearchRun\n'), ((8278, 8306), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (8293, 8306), True, 'import streamlit as st\n'), ((8440, 8468), 'streamlit.write', 'st.write', (["response['output']"], {}), "(response['output'])\n", (8448, 8468), True, 'import streamlit as st\n'), ((3974, 3997), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (3989, 3997), True, 'import streamlit as st\n'), ((4488, 4502), 'streamlit.container', 'st.container', ([], {}), '()\n', (4500, 4502), True, 'import streamlit as st\n'), ((7804, 7827), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (7819, 7827), True, 'import streamlit as st\n'), ((8344, 8358), 'streamlit.container', 'st.container', ([], {}), '()\n', (8356, 8358), True, 'import streamlit as st\n'), ((3737, 3809), 'streamlit.status', 'st.status', (['f"""**{step[0].tool}**: {step[0].tool_input}"""'], {'state': '"""complete"""'}), "(f'**{step[0].tool}**: {step[0].tool_input}', state='complete')\n", (3746, 3809), True, 'import streamlit as st\n'), ((3827, 3848), 'streamlit.write', 'st.write', (['step[0].log'], {}), '(step[0].log)\n', (3835, 3848), True, 'import streamlit as st\n'), ((3854, 3871), 'streamlit.write', 'st.write', (['step[1]'], {}), '(step[1])\n', (3862, 3871), True, 'import streamlit as st\n'), ((7567, 7639), 'streamlit.status', 'st.status', (['f"""**{step[0].tool}**: {step[0].tool_input}"""'], {'state': '"""complete"""'}), "(f'**{step[0].tool}**: {step[0].tool_input}', state='complete')\n", (7576, 7639), True, 'import streamlit as st\n'), ((7657, 7678), 'streamlit.write', 'st.write', (['step[0].log'], {}), '(step[0].log)\n', (7665, 7678), True, 'import streamlit as st\n'), ((7684, 7701), 'streamlit.write', 'st.write', (['step[1]'], {}), '(step[1])\n', (7692, 7701), True, 'import streamlit as st\n')] |
import os
import glob
import tqdm
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import pickle
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import KBinsDiscretizer, StandardScaler
from sklearn.pipeline import Pipeline
import joblib
# from sklearn.svm import SVC, LinearSVC
# from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix, precision_recall_fscore_support
from sklearn.preprocessing import StandardScaler
from sklearn.manifold import TSNE, Isomap
from .config import get_cfg
from .util.step_annotations import load_object_annotations, get_obj_anns
from IPython import embed
import warnings
warnings.simplefilter('once')
STATE = 'state'
def remap_labels(sdf, old_col, new_col):
RENAME = {
'[partial]': '',
'[full]': '',
'floss-underneath': 'ends-cut',
'floss-crossed': 'ends-cut',
'raisins[cooked]': 'raisins',
'oatmeal[cooked]+raisins': 'oatmeal+raisins',
'teabag': 'tea-bag',
'+stirrer': '',
'[stirred]': '',
'water+honey': 'water',
'with-quesadilla': 'with-food',
'with-pinwheels': 'with-food',
}
sdf[new_col] = sdf[old_col].copy()
for old, new in RENAME.items():
sdf[new_col] = sdf[new_col].str.replace(old, new)
sdf = sdf[~sdf[new_col].isin(['folding', 'on-plate', 'rolling'])]
return sdf
# ---------------------------------------------------------------------------- #
# Data Loading #
# ---------------------------------------------------------------------------- #
class bc:
HEADER = '\033[95m'
BLUE = '\033[94m'
CYAN = '\033[96m'
GREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
END = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
def load_data(cfg, data_file_pattern, include=None):
'''Load npz files (one per video) with embedding and label keys and concatenate
'''
# if os.path.isfile('dataset.pkl'):
# print('reading pickle')
# df = pd.read_pickle('dataset.pkl')
# print(df.head())
# return df
use_aug = cfg.EVAL.USE_AUGMENTATIONS
embeddings_list, df_list = [], []
class_map = {}
# steps_df, meta_df, object_names = load_annotations(cfg)
dfs = load_object_annotations(cfg)
fs = glob.glob(data_file_pattern)
# if cfg.EVAL.TRAIN_BASE_ROOT:
# fs += glob.glob(f'{cfg.EVAL.TRAIN_BASE_ROOT}/embeddings/{cfg.EVAL.DETECTION_NAME}/*/clip/*.npz')
if len(set(fs)) < len(fs):
print("Warning duplicate files in training set!\n\n")
input()
print(f"Found {len(fs)} files", fs[:1])
for f in tqdm.tqdm(fs, desc='loading data...'):
# if 'coffee_mit-eval' in f:
# embed()
if include and not any(fi in f for fi in include):
print("Skipping", f)
continue
data = np.load(f)
z = data['z']
z = z / np.linalg.norm(z, axis=-1, keepdims=True)
frame_idx = data['frame_index']
# maybe filter out augmentations
aug = data.get('augmented')
if aug is None or use_aug:
aug = np.zeros(len(z), dtype=bool)
z = z[~aug]
frame_idx = frame_idx[~aug]
# get video ID and track ID
video_id = data.get('video_name')
if video_id is None:
video_id = f.split('/')[-3]
else:
video_id = video_id.item()
video_id = os.path.splitext(video_id)[0]
track_id = data.get('track_id')
if track_id is None:
track_id = f.split('/')[-1].split('.')[0]
else:
track_id = track_id.item()
track_id = int(track_id)
if video_id not in dfs or track_id not in dfs[video_id]:
tqdm.tqdm.write(f"{bc.FAIL}Skipping{bc.END}: {video_id}: {track_id}")
continue
tqdm.tqdm.write(f"Using: {video_id}: {track_id}")
# get object state annotations
ann = get_obj_anns(remap_labels(dfs[video_id][track_id], 'state', 'state'), frame_idx)
embeddings_list.append(z)
df_list.append(pd.DataFrame({
'index': frame_idx,
'object': ann.object,
'state': ann.state,
'track_id': track_id,
'video_id': video_id,
}))
# print()
# print(df_list[-1][['object', 'state']].value_counts())
# print()
# if input(): embed()
if input():embed()
X = np.concatenate(embeddings_list)
df = pd.concat(df_list)
df['vector'] = list(X)
df.to_pickle('dataset.pkl')
return df
def load_data_from_db(cfg, state_col, emb_type='clip'):
import lancedb
dfs = []
fs = cfg.EVAL.EMBEDDING_DBS
f = os.path.join(cfg.DATASET.ROOT, f'{emb_type}.lancedb')
if not fs and os.path.isfile(f):
fs = [f]
for db_fname in fs:
print(db_fname)
assert os.path.isdir(db_fname)
db = lancedb.connect(db_fname)
for object_name in tqdm.tqdm(db.table_names()):
dfs.append(db.open_table(object_name).to_pandas())
df = pd.concat(dfs) if dfs else pd.DataFrame({state_col: []})
if state_col:
df['state'] = df[state_col]
return df
def read_split_file(fname):
lines = open(fname).read().splitlines()
lines = [l.strip() for l in lines]
lines = [l for l in lines if l and not l.startswith('#')]
return lines
# ---------------------------------------------------------------------------- #
# Training #
# ---------------------------------------------------------------------------- #
def train_eval(run_name, model, X, y, i_train, i_test, video_ids, plot_dir='plots', **meta):
'''Train and evaluate a model'''
print(run_name, model)
# plot_dir = f'{plot_dir}/{run_name}'
# os.makedirs(plot_dir, exist_ok=True)
X_train, X_test = X[i_train], X[i_test]
y_train, y_test = y[i_train], y[i_test]
# print(set(y_train))
# print(set(y_test))
# if input(): embed()
# from imblearn.over_sampling import SMOTE
# from imblearn.under_sampling import RandomUnderSampler
# from imblearn.pipeline import Pipeline
# # Create a pipeline to balance the classes using SMOTE
# pipeline = Pipeline([
# # ('oversample', SMOTE(sampling_strategy='auto')), # You can adjust sampling_strategy
# ('undersample', RandomUnderSampler(sampling_strategy='auto')) # You can adjust sampling_strategy
# ])
# X_test2, y_test2 = X_test, y_test
# X_test, y_test = pipeline.fit_resample(X_test, y_test)
# print(X_test2.shape, y_test2.shape, X_test.shape, y_test.shape)
assert not (set(video_ids[i_train]) & set(video_ids[i_test])), "Being extra sure... this is a nono"
# Standardize features
scaler = StandardScaler()
pipeline = Pipeline([
('scaler', scaler),
('model', model)
])
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# ----------------------------------- Train ---------------------------------- #
# Train the classifier
model.fit(X_train, y_train)
# Make predictions on the test set
y_pred = model.predict(X_test)
y_emis = model.predict_proba(X_test)
# with open(os.path.join(plot_dir, f'{run_name}.pkl'), 'rb') as f:
# pickle.dump(y_pred, f)
# Save the entire pipeline
with open(os.path.join(plot_dir, f'{run_name}_pipeline.pkl'), 'wb') as f:
joblib.dump(pipeline, f)
# ------------------------------- Visualization ------------------------------ #
# Generate plots
all_metrics = []
# compute vanilla metrics
meta['run_name'] = meta['metric_name'] = run_name
metrics = get_metrics(y_test, y_pred, **meta)
all_metrics.append(metrics)
tqdm.tqdm.write(f'Accuracy for {run_name}: {metrics["accuracy"]:.2f}')
# generate vanilla plots
video_ids_test = video_ids[i_test]
emission_plot(plot_dir, y_emis, y_test, model.classes_, f'{run_name}_ma0_', video_ids=video_ids_test)
emission_plot(plot_dir, y_emis, y_test, model.classes_, f'{run_name}_ma0_ypred_', show_ypred=True, video_ids=video_ids_test)
cm_plot(plot_dir, y_test, y_pred, model.classes_, f'{run_name}_')
# with moving average
for winsize in [2, 4, 8, 16]:
y_ = moving_average(y_emis, winsize)
y_pred_ = np.asarray(model.classes_)[np.argmax(y_, axis=1)]
# emission_plot(plot_dir, y_, y_test, model.classes_, f'{run_name}_ma{winsize}_', video_ids=video_ids_test)
emission_plot(plot_dir, y_, y_test, model.classes_, f'{run_name}_ma{winsize}_ypred_', show_ypred=True, video_ids=video_ids_test)
cm_plot(plot_dir, y_test, y_pred_, model.classes_, f'{run_name}_cm_ma{winsize}_')
meta = {**meta}
meta['metric_name'] = f'{run_name}_movingavg-{winsize}'
metrics = get_metrics(y_test, y_pred_, smoothing='ma', win_size=winsize, **meta)
all_metrics.append(metrics)
for alpha in [0.1, 0.2, 0.5]:
y_ = exponentially_decaying_average(y_emis, alpha)
y_pred_ = np.asarray(model.classes_)[np.argmax(y_, axis=1)]
emission_plot(plot_dir, y_, y_test, model.classes_, f'{run_name}_ema{alpha}_ypred_', show_ypred=True, video_ids=video_ids_test)
cm_plot(plot_dir, y_test, y_pred, model.classes_, f'{run_name}_')
meta = {**meta}
meta['metric_name'] = f'{run_name}_expmovingavg-{alpha}'
metrics = get_metrics(y_test, y_pred_, smoothing='ema', alpha=alpha, **meta)
all_metrics.append(metrics)
# y_hmm = hmm_forward(y_emis, len(model.classes_))
# emission_plot(plot_dir, y_hmm, y_test, model.classes_, f'{run_name}_trans_', video_ids=video_ids_test)
# emission_plot(plot_dir, y_hmm, y_test, model.classes_, f'{run_name}_trans_ypred_', show_ypred=True, video_ids=video_ids_test)
# # embed()
# get per class metrics
per_class_metrics = []
for c in np.unique(y):
per_class_metrics.append(get_metrics(
y_test[y_test==c], y_pred[y_test==c], label=c, **meta))
# tqdm.tqdm.write(f'F1 for {run_name}: {metrics["f1"]:.2f}')
return all_metrics, per_class_metrics
def get_metrics(y_test, y_pred, **meta):
precision, recall, f1_score, _ = precision_recall_fscore_support(y_test, y_pred, zero_division=np.nan, average='macro')
return {
'accuracy': accuracy_score(y_test, y_pred),
'f1': f1_score,
'ap': precision,
'avg_recal': recall,
**meta
}
# ---------------------------------------------------------------------------- #
# Visualization #
# ---------------------------------------------------------------------------- #
def emb_plot(plot_dir, X, y, prefix='', n=3000):
fname = f'{plot_dir}/{prefix}_proj.png'
if os.path.isfile(fname): return
print("creating emb plot", fname)
# Create a TSNE embedding plot (optional)
# tsne = TSNE(n_components=2)
m = Isomap()
i = np.random.choice(np.arange(len(X)), size=n)
X, y = X[i], y[i]
Z = m.fit_transform(X)
print(Z.shape)
plt.figure(figsize=(10, 8))
for c in np.unique(y):
plt.scatter(Z[y==c, 0], Z[y==c, 1], label=str(c), s=20, alpha=0.3)
plt.legend()
plt.title(f'Embedding Projection: {prefix}')
pltsave(fname)
def emission_plot(plot_dir, X, y, classes, prefix='', video_ids=None, show_ypred=False):
plt.figure(figsize=(10, 8))
plt.imshow(X.T, cmap='cubehelix', aspect='auto')
cs = {c: i for i, c in enumerate(classes)}
classes = list(classes)
for c in set(y) - set(cs):
cs[c] = len(cs)
classes.append(c)
plt.plot(np.array([cs[yi] for yi in y]), c='r')
if show_ypred:
plt.scatter(np.arange(len(X)), np.argmax(X, axis=1), c='white', s=5, alpha=0.2)
ic = range(len(classes))
plt.yticks(ic, [classes[i] for i in ic])
pltsave(f'{plot_dir}/{prefix}emissions.png')
os.makedirs(f'{plot_dir}/npzs', exist_ok=True)
np.savez(
f'{plot_dir}/npzs/{prefix}emissions.npz',
predictions=X, ground_truth=y,
video_ids=video_ids, classes=classes)
def cm_plot(plot_dir, y_test, y_pred, classes, prefix=''):
# classes = np.unique(y_test) if classes is None else classes
cm = confusion_matrix(y_test, y_pred, labels=classes, normalize='true')*100
# Plot and save the confusion matrix
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='.0f', cmap='magma', cbar=False, square=True,
xticklabels=classes, yticklabels=classes)
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title(f'Confusion Matrix')
pltsave(f'{plot_dir}/{prefix}confusion_matrix.png')
def n_videos_metrics(plot_dir, all_metrics, prefix=''):
# Plot accuracy and F1-score vs. the number of videos
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(all_metrics.n_videos, all_metrics.accuracy, marker='o')
plt.title('Accuracy vs. Number of Videos')
plt.xlabel('Number of Videos')
plt.ylabel('Accuracy')
plt.subplot(1, 2, 2)
plt.plot(all_metrics.n_videos, all_metrics.f1, marker='o', color='orange')
plt.title('F1 Score vs. Number of Videos')
plt.xlabel('Number of Videos')
plt.ylabel('F1 Score')
plt.tight_layout()
pltsave(f'{plot_dir}/{prefix}accuracy_f1_vs_videos.png')
def cross_model_metrics(plot_dir, all_metrics, prefix=''):
# Plot accuracy and F1-score vs. the number of videos
plt.figure(figsize=(15, 6))
plt.subplot(1, 2, 1)
for name, mdf in all_metrics[all_metrics.smoothing == 'ma'].groupby("run_name"):
plt.plot(mdf.win_size, mdf.f1, label=name)
plt.legend()
plt.title('F1 Score vs. Number of Videos')
plt.xlabel('Moving Average Window Size')
plt.ylabel('F1 Score')
plt.tight_layout()
plt.subplot(1, 2, 2)
for name, mdf in all_metrics[all_metrics.smoothing == 'ema'].groupby("run_name"):
plt.plot(mdf.alpha, mdf.f1, label=name)
plt.legend()
plt.title('F1 Score vs. EMA alpha * x[t] + (1 - alpha) * x[t-1]')
plt.xlabel('Exp Moving Average alpha')
plt.ylabel('F1 Score')
plt.tight_layout()
pltsave(f'{plot_dir}/{prefix}accuracy_f1_vs_smooth.png')
# def n_videos_class_metrics(plot_dir, all_metrics, prefix=''):
# # Plot accuracy and F1-score vs. the number of videos
# plt.figure(figsize=(12, 5))
# plt.subplot(1, 2, 1)
# for c, df in all_metrics.groupby('label'):
# # cc = df.class_count.mean()
# plt.plot(df.n_videos, df.accuracy, marker='o', label=c)#f'{c} {cc:.0f}'
# plt.legend()
# plt.title('Accuracy vs. Number of Videos')
# plt.xlabel('Number of Videos')
# plt.ylabel('Accuracy')
# plt.subplot(1, 2, 2)
# for c, df in all_metrics.groupby('label'):
# # cc = df.class_count.mean()
# plt.plot(df.n_videos, df.accuracy, marker='o', label=c)#f'{c} {cc:.0f}'
# plt.title('F1 Score vs. Number of Videos')
# plt.xlabel('Number of Videos')
# plt.ylabel('F1 Score')
# plt.legend()
# plt.tight_layout()
# pltsave(f'{plot_dir}/{prefix}accuracy_f1_vs_videos_per_class.png')
def pltsave(fname):
os.makedirs(os.path.dirname(fname) or '.', exist_ok=True)
plt.savefig(fname)
plt.close()
# ---------------------------------------------------------------------------- #
# HMM #
# ---------------------------------------------------------------------------- #
# def create_hmm(num_states, p_self=0.9):
# transition_matrix = np.eye(num_states) * p_self + (1.0 - p_self) / (num_states - 1)
# emission_matrix = np.eye(num_states)
# initial_prob = np.ones(num_states) / num_states
# return initial_prob, emission_matrix, transition_matrix
# Forward pass to compute the forward probabilities
def hmm_forward(sequence, num_states, p_self=0.9):
transition_matrix = np.eye(num_states) * p_self + (1.0 - p_self) / (num_states - 1)
forward_prob = np.zeros((len(sequence), num_states))
forward_prob[0, :] = 1 / num_states
for t in range(1, len(sequence)):
for j in range(num_states):
forward_prob[t] = np.sum(forward_prob[t - 1, i] * transition_matrix[i, j] for i in range(num_states))
forward_prob[t] *= 1.0 / np.sum(forward_prob[t])
return forward_prob
def moving_average(a, n=3, axis=0):
ret = np.cumsum(a, dtype=float, axis=axis)
ret[n:] = (ret[n:] - ret[:-n]) / n
ret[:n] = ret[:n] / np.arange(n)[:, None]
return ret
def exponentially_decaying_average(a, decay_rate):
assert 0 < decay_rate < 1, "Decay rate must be between 0 and 1."
result = a.copy()
result[0, :] = a[0, :]
for t in range(1, a.shape[0]):
result[t, :] = decay_rate * result[t - 1, :] + (1 - decay_rate) * a[t, :]
return result
# ---------------------------------------------------------------------------- #
# Training Meta Loop #
# ---------------------------------------------------------------------------- #
def get_data(cfg, STATE, full_split, emb_type='clip'):
emb_dirs = cfg.EVAL.EMBEDDING_DIRS or [os.path.join(cfg.DATASET.ROOT, 'embeddings-all', cfg.EVAL.DETECTION_NAME)]
ydf = load_data_from_db(cfg, state_col='mod_state')
db_train_split = ydf.video_id.unique().tolist()
ydf = pd.concat([
*[
load_data(cfg, f'{d}/{cfg.EVAL.DETECTION_NAME}/*/{emb_type}/*.npz', include=set(full_split) - set(ydf.video_id.unique()))
for d in emb_dirs
],
ydf
])
print(ydf.groupby('object').state.value_counts())
# sampling 12k per state
ydf = sample_random(ydf, STATE, 15000)
print(ydf.groupby('object').state.value_counts())
print('Nulls:', ydf[pd.isna(ydf.state)].video_id.value_counts())
assert None not in set(ydf.state)
return ydf, db_train_split
def sample_random(df, STATE, n):
df = df.groupby(STATE, group_keys=False).apply(lambda x: x.sample(min(len(x), n)))
return df
def get_models(cfg):
return [
# (KNeighborsClassifier, 'knn5', {'n_neighbors': 5}),
# (KNeighborsClassifier, 'knn11-50', {'n_neighbors': 11}, lambda df: sample_random(df, STATE, 50)),
# (KNeighborsClassifier, 'knn11-100', {'n_neighbors': 11}, lambda df: sample_random(df, STATE, 100)),
(KNeighborsClassifier, 'knn5-2000', {'n_neighbors': 5}, lambda df: sample_random(df, STATE, 2000)),
(KNeighborsClassifier, 'knn21-2000', {'n_neighbors': 21}, lambda df: sample_random(df, STATE, 2000)),
(KNeighborsClassifier, 'knn11-1000', {'n_neighbors': 11}, lambda df: sample_random(df, STATE, 1000)),
(KNeighborsClassifier, 'knn11-2000', {'n_neighbors': 11}, lambda df: sample_random(df, STATE, 2000)),
(KNeighborsClassifier, 'knn11-5000', {'n_neighbors': 11}, lambda df: sample_random(df, STATE, 5000)),
(KNeighborsClassifier, 'knn11-12000', {'n_neighbors': 11}, lambda df: sample_random(df, STATE, 12000)),
# (KNeighborsClassifier, 'knn50', {'n_neighbors': 50}),
(LogisticRegression, 'logreg', {}, lambda df: sample_random(df, STATE, 5000)),
(RandomForestClassifier, 'rf', {}, lambda df: sample_random(df, STATE, 5000)),
# (
# make_pipeline(
# StandardScaler(),
# KBinsDiscretizer(encode="onehot", random_state=0),
# LogisticRegression(random_state=0),
# ),
# 'kbins_logreg',
# {
# "kbinsdiscretizer__n_bins": np.arange(5, 8),
# "logisticregression__C": np.logspace(-1, 1, 3),
# },
# ),
]
def prepare_data(odf, STATE, sampler, train_split, val_split):
video_ids = odf['video_id'].values
unique_video_ids = np.unique(video_ids)
# obj_train_base_split = [f for f in train_base_split if f in video_ids and f not in val_split]
obj_train_split = [f for f in train_split if f in video_ids and f not in val_split]
obj_val_split = [f for f in val_split if f in video_ids]
# embed()
# obj_train_split = sorted(obj_train_split, key=lambda v: -len(odf[odf.video_id == v].state.unique()))
# print("Base Training split:", obj_train_base_split)
print("Training split:", obj_train_split)
print("Validation split:", obj_val_split)
print("Unused videos:", set(unique_video_ids) - set(obj_train_split+obj_val_split))
print("Missing videos:", set(obj_train_split+obj_val_split) - set(unique_video_ids))
i_train = np.isin(video_ids, obj_train_split)
# i_train = np.isin(video_ids, obj_train_base_split + obj_train_split[:nvids])
i_val = np.isin(video_ids, obj_val_split)
odfo=odf
if sampler is not None:
odf_train = sampler(odf.iloc[i_train])
odf_val = odf.iloc[i_val]
i_train = np.arange(len(odf_train))
i_val = np.arange(len(odf_val)) + i_train.max()+1
odf = pd.concat([odf_train, odf_val])
video_ids = odf['video_id'].values
i_train = np.isin(video_ids, obj_train_split)
i_val = np.isin(video_ids, obj_val_split)
X = np.array(list(odf['vector'].values))
y = odf[STATE].values
print()
print("all data:")
print('X', X.shape)
print('y', y.shape)
print(odf[['video_id', 'track_id', STATE]].value_counts())
# embed()
return X, y, video_ids, i_train, i_val
import ipdb
@ipdb.iex
def run(config_name):
cfg = get_cfg(config_name)
root_plot_dir = root_plot_dir_ = cfg.EVAL.PLOT_DIR or 'plots'
# i=0
# while os.path.isdir(root_plot_dir_):
# root_plot_dir_ = root_plot_dir + f'_{i}'
# i+=1
# root_plot_dir=root_plot_dir_
if os.path.isdir(root_plot_dir):
raise RuntimeError(f"{root_plot_dir} exists")
os.makedirs(root_plot_dir, exist_ok=True)
# STATE = 'super_simple_state'
# STATE = 'state'
train_split = read_split_file(cfg.EVAL.TRAIN_CSV)
train_base_split = read_split_file(cfg.EVAL.TRAIN_BASE_CSV)
val_splits = [(f, read_split_file(f)) for f in cfg.EVAL.VAL_CSVS]
print(len(train_base_split), train_base_split[:5])
print(len(train_split), train_split[:5])
print(len(val_splits), val_splits[:5])
full_train_split = train_split + train_base_split
full_val_split = [x for f, xs in val_splits for x in xs]
full_split = full_train_split + full_val_split
print(full_split)
for _,val_split in val_splits:
assert not set(full_train_split) & set(val_split), f"what are you doing silly {set(full_train_split) & set(val_split)}"
models = get_models(cfg)
cfg.EVAL.EMBEDDING_TYPES=['clip']
for emb_type in tqdm.tqdm(cfg.EVAL.EMBEDDING_TYPES, desc='embedding type'):
ydf, db_train_split = get_data(cfg, STATE, full_split)
emb_plot(f'{root_plot_dir}/{emb_type}', np.array(list(ydf['vector'].values)), ydf['object'].values, 'object')
# emb_plot(f'{root_plot_dir}/{emb_type}', np.array(list(ydf['vector'].values)), ydf[STATE].values, 'states')
for (val_split_fname, val_split) in val_splits:
val_split_name = val_split_fname.split('/')[-1].removesuffix('.txt')
for object_name, odf in ydf.groupby('object'):
plot_dir = f'{root_plot_dir}/{val_split_name}/{emb_type}/{object_name}'
os.makedirs(plot_dir, exist_ok=True)
all_metrics = []
all_per_class_metrics = []
for cls, name, kw, sampler in tqdm.tqdm(models, desc='models'):
X, y, video_ids, i_train, i_val = prepare_data(odf, STATE, sampler, db_train_split, val_split)
emb_plot(f'{root_plot_dir}/{emb_type}_{object_name}', X, y, 'states')
if not i_val.sum():
print(f"\n\n\n\nSKIPPING i_val is empty. {val_split}\n\n\n")
continue
print(f"Training with: train size: {len(i_train)} val size: {len(i_val)}")
print("Train Counts:")
train_counts = show_counts(y[i_train])
print(train_counts)
print("Val Counts:")
val_counts = show_counts(y[i_val])
print(val_counts)
model = cls(**kw)
metrics, per_class_metrics = train_eval(
f'{val_split_name}_{emb_type}_{name}', model,
X, y, i_train, i_val,
video_ids=video_ids,
plot_dir=plot_dir,
model_name=name,
# n_videos=nvids,
**kw)
all_metrics.extend(metrics)
all_per_class_metrics.extend(per_class_metrics)
all_metrics_df = pd.DataFrame(all_metrics)
all_per_class_metrics_df = pd.DataFrame(all_per_class_metrics)
all_metrics_df.to_csv(f'{plot_dir}/metrics.csv')
all_per_class_metrics_df.to_csv(f'{plot_dir}/class_metrics.csv')
# ---------- Show how it performs as a function of number of videos ---------- #
if len(all_metrics):
cross_model_metrics(plot_dir, all_metrics_df, f'{emb_type}_')
# n_videos_class_metrics(plot_dir, all_per_class_metrics_df, f'{emb_type}_')
def show_counts(y):
yu, counts = np.unique(y, return_counts=True)
for yui, c in zip(yu, counts):
print(yui, c)
return dict(zip(yu, counts))
import ipdb
@ipdb.iex
def show_data(config_name, emb_type='clip'):
cfg = get_cfg(config_name)
emb_dir = os.path.join(cfg.DATASET.ROOT, 'embeddings1', cfg.EVAL.DETECTION_NAME)
emb_types = cfg.EVAL.EMBEDDING_TYPES
data_file_pattern = f'{emb_dir}/*/{emb_type}/*.npz'
# dfs = load_object_annotations(cfg)
# # for vid, odfs in dfs.items():
# # print(vid)
# # print(set(odfs))
# # input()
# for vid, odfs in dfs.items():
# print(vid)
# print({k: odfs[k].shape for k in odfs})
# for vid, odfs in dfs.items():
# print(vid)
# for k in odfs:
# print(k)
# print(odfs[k])
# embed()
# X, y, video_ids, class_map = load_data(cfg, data_file_pattern, use_aug=False)
# df = pd.DataFrame({'vids': video_ids, 'y': y})
# df['label'] = df.y.apply(lambda y: class_map[y])
# for v, rows in df.groupby('vids'):
# print(v)
# print(rows.label.value_counts())
df = load_data(cfg, data_file_pattern, use_aug=False)
for object_name, odf in df.groupby('object'):
print(object_name)
print(odf[['state']].value_counts())
# print(odf[['state', 'video_id']].value_counts())
x = odf[['state', 'video_id']].value_counts().unstack().fillna(0)
print(x)
x.to_csv(f"{object_name}_video_counts.csv")
# embed()
if __name__ == '__main__':
import fire
fire.Fire() | [
"lancedb.connect"
] | [((938, 967), 'warnings.simplefilter', 'warnings.simplefilter', (['"""once"""'], {}), "('once')\n", (959, 967), False, 'import warnings\n'), ((2673, 2701), 'glob.glob', 'glob.glob', (['data_file_pattern'], {}), '(data_file_pattern)\n', (2682, 2701), False, 'import glob\n'), ((3011, 3048), 'tqdm.tqdm', 'tqdm.tqdm', (['fs'], {'desc': '"""loading data..."""'}), "(fs, desc='loading data...')\n", (3020, 3048), False, 'import tqdm\n'), ((4817, 4848), 'numpy.concatenate', 'np.concatenate', (['embeddings_list'], {}), '(embeddings_list)\n', (4831, 4848), True, 'import numpy as np\n'), ((4858, 4876), 'pandas.concat', 'pd.concat', (['df_list'], {}), '(df_list)\n', (4867, 4876), True, 'import pandas as pd\n'), ((5081, 5134), 'os.path.join', 'os.path.join', (['cfg.DATASET.ROOT', 'f"""{emb_type}.lancedb"""'], {}), "(cfg.DATASET.ROOT, f'{emb_type}.lancedb')\n", (5093, 5134), False, 'import os\n'), ((7191, 7207), 'sklearn.preprocessing.StandardScaler', 'StandardScaler', ([], {}), '()\n', (7205, 7207), False, 'from sklearn.preprocessing import StandardScaler\n'), ((7223, 7271), 'sklearn.pipeline.Pipeline', 'Pipeline', (["[('scaler', scaler), ('model', model)]"], {}), "([('scaler', scaler), ('model', model)])\n", (7231, 7271), False, 'from sklearn.pipeline import Pipeline\n'), ((8186, 8256), 'tqdm.tqdm.write', 'tqdm.tqdm.write', (['f"""Accuracy for {run_name}: {metrics[\'accuracy\']:.2f}"""'], {}), '(f"Accuracy for {run_name}: {metrics[\'accuracy\']:.2f}")\n', (8201, 8256), False, 'import tqdm\n'), ((10331, 10343), 'numpy.unique', 'np.unique', (['y'], {}), '(y)\n', (10340, 10343), True, 'import numpy as np\n'), ((10652, 10742), 'sklearn.metrics.precision_recall_fscore_support', 'precision_recall_fscore_support', (['y_test', 'y_pred'], {'zero_division': 'np.nan', 'average': '"""macro"""'}), "(y_test, y_pred, zero_division=np.nan,\n average='macro')\n", (10683, 10742), False, 'from sklearn.metrics import accuracy_score, confusion_matrix, precision_recall_fscore_support\n'), ((11250, 11271), 'os.path.isfile', 'os.path.isfile', (['fname'], {}), '(fname)\n', (11264, 11271), False, 'import os\n'), ((11406, 11414), 'sklearn.manifold.Isomap', 'Isomap', ([], {}), '()\n', (11412, 11414), False, 'from sklearn.manifold import TSNE, Isomap\n'), ((11539, 11566), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(10, 8)'}), '(figsize=(10, 8))\n', (11549, 11566), True, 'import matplotlib.pyplot as plt\n'), ((11580, 11592), 'numpy.unique', 'np.unique', (['y'], {}), '(y)\n', (11589, 11592), True, 'import numpy as np\n'), ((11673, 11685), 'matplotlib.pyplot.legend', 'plt.legend', ([], {}), '()\n', (11683, 11685), True, 'import matplotlib.pyplot as plt\n'), ((11690, 11734), 'matplotlib.pyplot.title', 'plt.title', (['f"""Embedding Projection: {prefix}"""'], {}), "(f'Embedding Projection: {prefix}')\n", (11699, 11734), True, 'import matplotlib.pyplot as plt\n'), ((11849, 11876), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(10, 8)'}), '(figsize=(10, 8))\n', (11859, 11876), True, 'import matplotlib.pyplot as plt\n'), ((11881, 11929), 'matplotlib.pyplot.imshow', 'plt.imshow', (['X.T'], {'cmap': '"""cubehelix"""', 'aspect': '"""auto"""'}), "(X.T, cmap='cubehelix', aspect='auto')\n", (11891, 11929), True, 'import matplotlib.pyplot as plt\n'), ((12278, 12318), 'matplotlib.pyplot.yticks', 'plt.yticks', (['ic', '[classes[i] for i in ic]'], {}), '(ic, [classes[i] for i in ic])\n', (12288, 12318), True, 'import matplotlib.pyplot as plt\n'), ((12372, 12418), 'os.makedirs', 'os.makedirs', (['f"""{plot_dir}/npzs"""'], {'exist_ok': '(True)'}), "(f'{plot_dir}/npzs', exist_ok=True)\n", (12383, 12418), False, 'import os\n'), ((12423, 12546), 'numpy.savez', 'np.savez', (['f"""{plot_dir}/npzs/{prefix}emissions.npz"""'], {'predictions': 'X', 'ground_truth': 'y', 'video_ids': 'video_ids', 'classes': 'classes'}), "(f'{plot_dir}/npzs/{prefix}emissions.npz', predictions=X,\n ground_truth=y, video_ids=video_ids, classes=classes)\n", (12431, 12546), True, 'import numpy as np\n'), ((12822, 12849), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(10, 8)'}), '(figsize=(10, 8))\n', (12832, 12849), True, 'import matplotlib.pyplot as plt\n'), ((12854, 12978), 'seaborn.heatmap', 'sns.heatmap', (['cm'], {'annot': '(True)', 'fmt': '""".0f"""', 'cmap': '"""magma"""', 'cbar': '(False)', 'square': '(True)', 'xticklabels': 'classes', 'yticklabels': 'classes'}), "(cm, annot=True, fmt='.0f', cmap='magma', cbar=False, square=\n True, xticklabels=classes, yticklabels=classes)\n", (12865, 12978), True, 'import seaborn as sns\n'), ((12994, 13017), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Predicted"""'], {}), "('Predicted')\n", (13004, 13017), True, 'import matplotlib.pyplot as plt\n'), ((13022, 13042), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Actual"""'], {}), "('Actual')\n", (13032, 13042), True, 'import matplotlib.pyplot as plt\n'), ((13047, 13077), 'matplotlib.pyplot.title', 'plt.title', (['f"""Confusion Matrix"""'], {}), "(f'Confusion Matrix')\n", (13056, 13077), True, 'import matplotlib.pyplot as plt\n'), ((13254, 13281), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(12, 5)'}), '(figsize=(12, 5))\n', (13264, 13281), True, 'import matplotlib.pyplot as plt\n'), ((13286, 13306), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(2)', '(1)'], {}), '(1, 2, 1)\n', (13297, 13306), True, 'import matplotlib.pyplot as plt\n'), ((13311, 13375), 'matplotlib.pyplot.plot', 'plt.plot', (['all_metrics.n_videos', 'all_metrics.accuracy'], {'marker': '"""o"""'}), "(all_metrics.n_videos, all_metrics.accuracy, marker='o')\n", (13319, 13375), True, 'import matplotlib.pyplot as plt\n'), ((13380, 13422), 'matplotlib.pyplot.title', 'plt.title', (['"""Accuracy vs. Number of Videos"""'], {}), "('Accuracy vs. Number of Videos')\n", (13389, 13422), True, 'import matplotlib.pyplot as plt\n'), ((13427, 13457), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Number of Videos"""'], {}), "('Number of Videos')\n", (13437, 13457), True, 'import matplotlib.pyplot as plt\n'), ((13462, 13484), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Accuracy"""'], {}), "('Accuracy')\n", (13472, 13484), True, 'import matplotlib.pyplot as plt\n'), ((13490, 13510), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(2)', '(2)'], {}), '(1, 2, 2)\n', (13501, 13510), True, 'import matplotlib.pyplot as plt\n'), ((13515, 13589), 'matplotlib.pyplot.plot', 'plt.plot', (['all_metrics.n_videos', 'all_metrics.f1'], {'marker': '"""o"""', 'color': '"""orange"""'}), "(all_metrics.n_videos, all_metrics.f1, marker='o', color='orange')\n", (13523, 13589), True, 'import matplotlib.pyplot as plt\n'), ((13594, 13636), 'matplotlib.pyplot.title', 'plt.title', (['"""F1 Score vs. Number of Videos"""'], {}), "('F1 Score vs. Number of Videos')\n", (13603, 13636), True, 'import matplotlib.pyplot as plt\n'), ((13641, 13671), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Number of Videos"""'], {}), "('Number of Videos')\n", (13651, 13671), True, 'import matplotlib.pyplot as plt\n'), ((13676, 13698), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""F1 Score"""'], {}), "('F1 Score')\n", (13686, 13698), True, 'import matplotlib.pyplot as plt\n'), ((13703, 13721), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (13719, 13721), True, 'import matplotlib.pyplot as plt\n'), ((13906, 13933), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(15, 6)'}), '(figsize=(15, 6))\n', (13916, 13933), True, 'import matplotlib.pyplot as plt\n'), ((13938, 13958), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(2)', '(1)'], {}), '(1, 2, 1)\n', (13949, 13958), True, 'import matplotlib.pyplot as plt\n'), ((14099, 14111), 'matplotlib.pyplot.legend', 'plt.legend', ([], {}), '()\n', (14109, 14111), True, 'import matplotlib.pyplot as plt\n'), ((14117, 14159), 'matplotlib.pyplot.title', 'plt.title', (['"""F1 Score vs. Number of Videos"""'], {}), "('F1 Score vs. Number of Videos')\n", (14126, 14159), True, 'import matplotlib.pyplot as plt\n'), ((14164, 14204), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Moving Average Window Size"""'], {}), "('Moving Average Window Size')\n", (14174, 14204), True, 'import matplotlib.pyplot as plt\n'), ((14209, 14231), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""F1 Score"""'], {}), "('F1 Score')\n", (14219, 14231), True, 'import matplotlib.pyplot as plt\n'), ((14236, 14254), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (14252, 14254), True, 'import matplotlib.pyplot as plt\n'), ((14260, 14280), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(2)', '(2)'], {}), '(1, 2, 2)\n', (14271, 14280), True, 'import matplotlib.pyplot as plt\n'), ((14419, 14431), 'matplotlib.pyplot.legend', 'plt.legend', ([], {}), '()\n', (14429, 14431), True, 'import matplotlib.pyplot as plt\n'), ((14437, 14502), 'matplotlib.pyplot.title', 'plt.title', (['"""F1 Score vs. EMA alpha * x[t] + (1 - alpha) * x[t-1]"""'], {}), "('F1 Score vs. EMA alpha * x[t] + (1 - alpha) * x[t-1]')\n", (14446, 14502), True, 'import matplotlib.pyplot as plt\n'), ((14507, 14545), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Exp Moving Average alpha"""'], {}), "('Exp Moving Average alpha')\n", (14517, 14545), True, 'import matplotlib.pyplot as plt\n'), ((14550, 14572), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""F1 Score"""'], {}), "('F1 Score')\n", (14560, 14572), True, 'import matplotlib.pyplot as plt\n'), ((14577, 14595), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (14593, 14595), True, 'import matplotlib.pyplot as plt\n'), ((15666, 15684), 'matplotlib.pyplot.savefig', 'plt.savefig', (['fname'], {}), '(fname)\n', (15677, 15684), True, 'import matplotlib.pyplot as plt\n'), ((15689, 15700), 'matplotlib.pyplot.close', 'plt.close', ([], {}), '()\n', (15698, 15700), True, 'import matplotlib.pyplot as plt\n'), ((16849, 16885), 'numpy.cumsum', 'np.cumsum', (['a'], {'dtype': 'float', 'axis': 'axis'}), '(a, dtype=float, axis=axis)\n', (16858, 16885), True, 'import numpy as np\n'), ((20276, 20296), 'numpy.unique', 'np.unique', (['video_ids'], {}), '(video_ids)\n', (20285, 20296), True, 'import numpy as np\n'), ((21011, 21046), 'numpy.isin', 'np.isin', (['video_ids', 'obj_train_split'], {}), '(video_ids, obj_train_split)\n', (21018, 21046), True, 'import numpy as np\n'), ((21142, 21175), 'numpy.isin', 'np.isin', (['video_ids', 'obj_val_split'], {}), '(video_ids, obj_val_split)\n', (21149, 21175), True, 'import numpy as np\n'), ((21502, 21537), 'numpy.isin', 'np.isin', (['video_ids', 'obj_train_split'], {}), '(video_ids, obj_train_split)\n', (21509, 21537), True, 'import numpy as np\n'), ((21550, 21583), 'numpy.isin', 'np.isin', (['video_ids', 'obj_val_split'], {}), '(video_ids, obj_val_split)\n', (21557, 21583), True, 'import numpy as np\n'), ((22162, 22190), 'os.path.isdir', 'os.path.isdir', (['root_plot_dir'], {}), '(root_plot_dir)\n', (22175, 22190), False, 'import os\n'), ((22250, 22291), 'os.makedirs', 'os.makedirs', (['root_plot_dir'], {'exist_ok': '(True)'}), '(root_plot_dir, exist_ok=True)\n', (22261, 22291), False, 'import os\n'), ((23125, 23183), 'tqdm.tqdm', 'tqdm.tqdm', (['cfg.EVAL.EMBEDDING_TYPES'], {'desc': '"""embedding type"""'}), "(cfg.EVAL.EMBEDDING_TYPES, desc='embedding type')\n", (23134, 23183), False, 'import tqdm\n'), ((25907, 25939), 'numpy.unique', 'np.unique', (['y'], {'return_counts': '(True)'}), '(y, return_counts=True)\n', (25916, 25939), True, 'import numpy as np\n'), ((26143, 26213), 'os.path.join', 'os.path.join', (['cfg.DATASET.ROOT', '"""embeddings1"""', 'cfg.EVAL.DETECTION_NAME'], {}), "(cfg.DATASET.ROOT, 'embeddings1', cfg.EVAL.DETECTION_NAME)\n", (26155, 26213), False, 'import os\n'), ((27455, 27466), 'fire.Fire', 'fire.Fire', ([], {}), '()\n', (27464, 27466), False, 'import fire\n'), ((3237, 3247), 'numpy.load', 'np.load', (['f'], {}), '(f)\n', (3244, 3247), True, 'import numpy as np\n'), ((4220, 4269), 'tqdm.tqdm.write', 'tqdm.tqdm.write', (['f"""Using: {video_id}: {track_id}"""'], {}), "(f'Using: {video_id}: {track_id}')\n", (4235, 4269), False, 'import tqdm\n'), ((4801, 4808), 'IPython.embed', 'embed', ([], {}), '()\n', (4806, 4808), False, 'from IPython import embed\n'), ((5153, 5170), 'os.path.isfile', 'os.path.isfile', (['f'], {}), '(f)\n', (5167, 5170), False, 'import os\n'), ((5252, 5275), 'os.path.isdir', 'os.path.isdir', (['db_fname'], {}), '(db_fname)\n', (5265, 5275), False, 'import os\n'), ((5289, 5314), 'lancedb.connect', 'lancedb.connect', (['db_fname'], {}), '(db_fname)\n', (5304, 5314), False, 'import lancedb\n'), ((5443, 5457), 'pandas.concat', 'pd.concat', (['dfs'], {}), '(dfs)\n', (5452, 5457), True, 'import pandas as pd\n'), ((5470, 5499), 'pandas.DataFrame', 'pd.DataFrame', (['{state_col: []}'], {}), '({state_col: []})\n', (5482, 5499), True, 'import pandas as pd\n'), ((7860, 7884), 'joblib.dump', 'joblib.dump', (['pipeline', 'f'], {}), '(pipeline, f)\n', (7871, 7884), False, 'import joblib\n'), ((10772, 10802), 'sklearn.metrics.accuracy_score', 'accuracy_score', (['y_test', 'y_pred'], {}), '(y_test, y_pred)\n', (10786, 10802), False, 'from sklearn.metrics import accuracy_score, confusion_matrix, precision_recall_fscore_support\n'), ((12099, 12129), 'numpy.array', 'np.array', (['[cs[yi] for yi in y]'], {}), '([cs[yi] for yi in y])\n', (12107, 12129), True, 'import numpy as np\n'), ((12706, 12772), 'sklearn.metrics.confusion_matrix', 'confusion_matrix', (['y_test', 'y_pred'], {'labels': 'classes', 'normalize': '"""true"""'}), "(y_test, y_pred, labels=classes, normalize='true')\n", (12722, 12772), False, 'from sklearn.metrics import accuracy_score, confusion_matrix, precision_recall_fscore_support\n'), ((14052, 14094), 'matplotlib.pyplot.plot', 'plt.plot', (['mdf.win_size', 'mdf.f1'], {'label': 'name'}), '(mdf.win_size, mdf.f1, label=name)\n', (14060, 14094), True, 'import matplotlib.pyplot as plt\n'), ((14375, 14414), 'matplotlib.pyplot.plot', 'plt.plot', (['mdf.alpha', 'mdf.f1'], {'label': 'name'}), '(mdf.alpha, mdf.f1, label=name)\n', (14383, 14414), True, 'import matplotlib.pyplot as plt\n'), ((21416, 21447), 'pandas.concat', 'pd.concat', (['[odf_train, odf_val]'], {}), '([odf_train, odf_val])\n', (21425, 21447), True, 'import pandas as pd\n'), ((3286, 3327), 'numpy.linalg.norm', 'np.linalg.norm', (['z'], {'axis': '(-1)', 'keepdims': '(True)'}), '(z, axis=-1, keepdims=True)\n', (3300, 3327), True, 'import numpy as np\n'), ((3804, 3830), 'os.path.splitext', 'os.path.splitext', (['video_id'], {}), '(video_id)\n', (3820, 3830), False, 'import os\n'), ((4121, 4190), 'tqdm.tqdm.write', 'tqdm.tqdm.write', (['f"""{bc.FAIL}Skipping{bc.END}: {video_id}: {track_id}"""'], {}), "(f'{bc.FAIL}Skipping{bc.END}: {video_id}: {track_id}')\n", (4136, 4190), False, 'import tqdm\n'), ((4462, 4586), 'pandas.DataFrame', 'pd.DataFrame', (["{'index': frame_idx, 'object': ann.object, 'state': ann.state, 'track_id':\n track_id, 'video_id': video_id}"], {}), "({'index': frame_idx, 'object': ann.object, 'state': ann.state,\n 'track_id': track_id, 'video_id': video_id})\n", (4474, 4586), True, 'import pandas as pd\n'), ((7788, 7838), 'os.path.join', 'os.path.join', (['plot_dir', 'f"""{run_name}_pipeline.pkl"""'], {}), "(plot_dir, f'{run_name}_pipeline.pkl')\n", (7800, 7838), False, 'import os\n'), ((8755, 8781), 'numpy.asarray', 'np.asarray', (['model.classes_'], {}), '(model.classes_)\n', (8765, 8781), True, 'import numpy as np\n'), ((8782, 8803), 'numpy.argmax', 'np.argmax', (['y_'], {'axis': '(1)'}), '(y_, axis=1)\n', (8791, 8803), True, 'import numpy as np\n'), ((9474, 9500), 'numpy.asarray', 'np.asarray', (['model.classes_'], {}), '(model.classes_)\n', (9484, 9500), True, 'import numpy as np\n'), ((9501, 9522), 'numpy.argmax', 'np.argmax', (['y_'], {'axis': '(1)'}), '(y_, axis=1)\n', (9510, 9522), True, 'import numpy as np\n'), ((12196, 12216), 'numpy.argmax', 'np.argmax', (['X'], {'axis': '(1)'}), '(X, axis=1)\n', (12205, 12216), True, 'import numpy as np\n'), ((15616, 15638), 'os.path.dirname', 'os.path.dirname', (['fname'], {}), '(fname)\n', (15631, 15638), False, 'import os\n'), ((16366, 16384), 'numpy.eye', 'np.eye', (['num_states'], {}), '(num_states)\n', (16372, 16384), True, 'import numpy as np\n'), ((16949, 16961), 'numpy.arange', 'np.arange', (['n'], {}), '(n)\n', (16958, 16961), True, 'import numpy as np\n'), ((17638, 17711), 'os.path.join', 'os.path.join', (['cfg.DATASET.ROOT', '"""embeddings-all"""', 'cfg.EVAL.DETECTION_NAME'], {}), "(cfg.DATASET.ROOT, 'embeddings-all', cfg.EVAL.DETECTION_NAME)\n", (17650, 17711), False, 'import os\n'), ((16752, 16775), 'numpy.sum', 'np.sum', (['forward_prob[t]'], {}), '(forward_prob[t])\n', (16758, 16775), True, 'import numpy as np\n'), ((23784, 23820), 'os.makedirs', 'os.makedirs', (['plot_dir'], {'exist_ok': '(True)'}), '(plot_dir, exist_ok=True)\n', (23795, 23820), False, 'import os\n'), ((23945, 23977), 'tqdm.tqdm', 'tqdm.tqdm', (['models'], {'desc': '"""models"""'}), "(models, desc='models')\n", (23954, 23977), False, 'import tqdm\n'), ((25301, 25326), 'pandas.DataFrame', 'pd.DataFrame', (['all_metrics'], {}), '(all_metrics)\n', (25313, 25326), True, 'import pandas as pd\n'), ((25370, 25405), 'pandas.DataFrame', 'pd.DataFrame', (['all_per_class_metrics'], {}), '(all_per_class_metrics)\n', (25382, 25405), True, 'import pandas as pd\n'), ((18253, 18271), 'pandas.isna', 'pd.isna', (['ydf.state'], {}), '(ydf.state)\n', (18260, 18271), True, 'import pandas as pd\n')] |
"""LanceDB vector store."""
from typing import Any, List, Optional
from llama_index.schema import MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode
from llama_index.vector_stores.types import (
MetadataFilters,
NodeWithEmbedding,
VectorStore,
VectorStoreQuery,
VectorStoreQueryResult,
)
from llama_index.vector_stores.utils import node_to_metadata_dict
def _to_lance_filter(standard_filters: MetadataFilters) -> Any:
"""Translate standard metadata filters to Lance specific spec."""
filters = []
for filter in standard_filters.filters:
if isinstance(filter.value, str):
filters.append(filter.key + ' = "' + filter.value + '"')
else:
filters.append(filter.key + " = " + str(filter.value))
return " AND ".join(filters)
class LanceDBVectorStore(VectorStore):
"""The LanceDB Vector Store.
Stores text and embeddings in LanceDB. The vector store will open an existing
LanceDB dataset or create the dataset if it does not exist.
Args:
uri (str, required): Location where LanceDB will store its files.
table_name (str, optional): The table name where the embeddings will be stored.
Defaults to "vectors".
nprobes (int, optional): The number of probes used.
A higher number makes search more accurate but also slower.
Defaults to 20.
refine_factor: (int, optional): Refine the results by reading extra elements
and re-ranking them in memory.
Defaults to None
Raises:
ImportError: Unable to import `lancedb`.
Returns:
LanceDBVectorStore: VectorStore that supports creating LanceDB datasets and
querying it.
"""
stores_text = True
flat_metadata: bool = True
def __init__(
self,
uri: str,
table_name: str = "vectors",
nprobes: int = 20,
refine_factor: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Init params."""
import_err_msg = "`lancedb` package not found, please run `pip install lancedb`"
try:
import lancedb # noqa: F401
except ImportError:
raise ImportError(import_err_msg)
self.connection = lancedb.connect(uri)
self.uri = uri
self.table_name = table_name
self.nprobes = nprobes
self.refine_factor = refine_factor
@property
def client(self) -> None:
"""Get client."""
return None
def add(
self,
embedding_results: List[NodeWithEmbedding],
) -> List[str]:
data = []
ids = []
for result in embedding_results:
metadata = node_to_metadata_dict(
result.node, remove_text=True, flat_metadata=self.flat_metadata
)
append_data = {
"id": result.id,
"doc_id": result.ref_doc_id,
"vector": result.embedding,
"text": result.node.get_content(metadata_mode=MetadataMode.NONE),
}
append_data.update(metadata)
data.append(append_data)
ids.append(result.id)
if self.table_name in self.connection.table_names():
tbl = self.connection.open_table(self.table_name)
tbl.add(data)
else:
self.connection.create_table(self.table_name, data)
return ids
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
"""
Delete nodes using with ref_doc_id.
Args:
ref_doc_id (str): The doc_id of the document to delete.
"""
table = self.connection.open_table(self.table_name)
table.delete('document_id = "' + ref_doc_id + '"')
def query(
self,
query: VectorStoreQuery,
**kwargs: Any,
) -> VectorStoreQueryResult:
"""Query index for top k most similar nodes."""
if query.filters is not None:
if "where" in kwargs:
raise ValueError(
"Cannot specify filter via both query and kwargs. "
"Use kwargs only for lancedb specific items that are "
"not supported via the generic query interface."
)
where = _to_lance_filter(query.filters)
else:
where = kwargs.pop("where", None)
table = self.connection.open_table(self.table_name)
lance_query = (
table.search(query.query_embedding)
.limit(query.similarity_top_k)
.where(where)
.nprobes(self.nprobes)
)
if self.refine_factor is not None:
lance_query.refine_factor(self.refine_factor)
results = lance_query.to_df()
nodes = []
for _, item in results.iterrows():
node = TextNode(
text=item.text,
id_=item.id,
relationships={
NodeRelationship.SOURCE: RelatedNodeInfo(node_id=item.doc_id),
},
)
nodes.append(node)
return VectorStoreQueryResult(
nodes=nodes,
similarities=results["score"].tolist(),
ids=results["id"].tolist(),
)
| [
"lancedb.connect"
] | [((2271, 2291), 'lancedb.connect', 'lancedb.connect', (['uri'], {}), '(uri)\n', (2286, 2291), False, 'import lancedb\n'), ((2716, 2807), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['result.node'], {'remove_text': '(True)', 'flat_metadata': 'self.flat_metadata'}), '(result.node, remove_text=True, flat_metadata=self.\n flat_metadata)\n', (2737, 2807), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((5023, 5059), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': 'item.doc_id'}), '(node_id=item.doc_id)\n', (5038, 5059), False, 'from llama_index.schema import MetadataMode, NodeRelationship, RelatedNodeInfo, TextNode\n')] |