向量嵌入與 Pinecone 索引最佳實踐

import openai
import time

# 指定嵌入模型
embedding_model = "text-embedding-3-small"
client = openai.OpenAI()

def get_embedding(text, model=embedding_model):
    # 將換行符替換為空格，以確保輸入格式一致
    text = text.replace("\n", " ")
    response = client.embeddings.create(input=[text], model=model)
    embedding = response.data[0].embedding
    return embedding

start_time = time.time()
chunk_start = 0
chunk_end = 1000
pause_time = 3  # 避免觸發 API 速率限制
embeddings = []
counter = 1

while chunk_end <= len(chunks):
    chunks_to_embed = chunks[chunk_start:chunk_end]
    current_embeddings = []
    for chunk in chunks_to_embed:
        embedding = get_embedding(chunk, model=embedding_model)
        current_embeddings.append(embedding)
    embeddings.extend(current_embeddings)
    chunk_start += 1000
    chunk_end += 1000
    time.sleep(pause_time)  
    counter += 1
    print(f"Batch {counter -1} embedded.")

# 處理剩餘的 chunk
if chunk_end < len(chunks):  
    remaining_chunks = chunks[chunk_end:]
    remaining_embeddings = [get_embedding(chunk, model=embedding_model) for chunk in remaining_chunks]
    embeddings.extend(remaining_embeddings)

print("All chunks processed.")
print(f"Response Time: {time.time() - start_time} seconds")

dsize = 5
total = dsize * len(chunks)
print("Total size", total)

duplicated_chunks = []
duplicated_embeddings = []

for i in range(len(chunks)):
    for _ in range(dsize):
        duplicated_chunks.append(chunks[i])
        duplicated_embeddings.append(embeddings[i])

print(f"Number of duplicated chunks: {len(duplicated_chunks)}")
print(f"Number of duplicated embeddings: {len(duplicated_embeddings)}")

import os
from pinecone import Pinecone, ServerlessSpec

api_key = os.environ.get('PINECONE_API_KEY') or 'YOUR_API_KEY'
pc = Pinecone(api_key=api_key)

index_name = "your-index-name"
cloud = os.environ.get('PINECONE_CLOUD') or 'aws'
region = os.environ.get('PINECONE_REGION') or 'us-east-1'
spec = ServerlessSpec(cloud=cloud, region=region)

if index_name not in pc.list_indexes().names():
    pc.create_index(
        index_name,
        dimension=1536,
        metric='cosine',
        spec=spec
    )
    time.sleep(1)

index = pc.Index(index_name)
index.describe_index_stats()

import pinecone
import time
import sys

def upsert_to_pinecone(data, batch_size):
    for i in range(0, len(data), batch_size):
        batch = data[i:i + batch_size]
        index.upsert(vectors=batch)

def get_batch_size(data, limit=4000000):  
    total_size = 0
    batch_size = 0
    for item in data:
        item_size = sum([sys.getsizeof(v) for v in item.values()])
        if total_size + item_size > limit:
            break
        total_size += item_size
        batch_size += 1
    return batch_size

def batch_upsert(data):
    total = len(data)
    i = 0
    while i < total:
        batch_size = get_batch_size(data[i:])
        batch = data[i:i + batch_size]
        if batch:
            upsert_to_pinecone(batch, batch_size)
            i += batch_size
            print(f"Upserted {i}/{total} items...")  
        else:
            break
    print("Upsert complete.")

import openai
import time

embedding_model = "text-embedding-3-small"

# 初始化 OpenAI 客戶端
client = openai.OpenAI()

def get_embedding(text, model=embedding_model):
    text = text.replace("\n", " ")
    response = client.embeddings.create(input=[text], model=model)
    embedding = response.data[0].embedding
    return embedding

import time
start_time = time.time() # 開始計時

# 目標向量
query_text = "Customer Henderson CreditScore 599 Age 37 Tenure 2 Balance 83788.88 EstimatedSalary 101348.88 HasCrCard 1 IsActiveMember 1 Complain 1 Exited 1"
query_embedding = get_embedding(query_text, model=embedding_model)

# 查詢 Pinecone 索引
query_results = index.query(
    vector=query_embedding,
    top_k=5,
    include_metadata=True,
)

# 顯示查詢結果和中繼資料
print("Query Results:")
for match in query_results['matches']:
    print(f"ID: {match['id']}, Score: {match['score']}")
    if 'metadata' in match and 'text' in match['metadata']:
        print(f"Text: {match['metadata']['text']}")
    else:
        print("No metadata available.")

response_time = time.time() - start_time # 停止計時
print(f"Querying response time: {response_time:.2f} seconds") # 顯示查詢時間

relevant_texts = [match['metadata']['text'] for match in query_results['matches']]
combined_text = '\n'.join(relevant_texts) # 使用換行符連線文字
print(combined_text)

# 組合文字
combined_context = "\n".join(relevant_texts)

# 提示
query_prompt = "根據以下客戶銀行記錄，撰寫一封客製化的電子郵件："
itext = query_prompt + query_text + combined_context

# 增強的輸入
print("Prompt for the Generative AI model:", itext)

from openai import OpenAI
client = OpenAI()
gpt_model = "gpt-4"

import time
start_time = time.time()  # 開始計時

response = client.chat.completions.create(
    model=gpt_model,
    messages=[
        {
            "role": "system",
            "content": "你是一位社群經理，可以撰寫引人入勝的電子郵件。"
        },
        {
            "role": "user",
            "content": itext
        }
    ],
    temperature=0,
    max_tokens=300,
    top_p=1,
    frequency_penalty=0,
    presence_penalty=0
)

print(response.choices[0].message.content)

response_time = time.time() - start_time  # 停止計時
print(f"Querying response time: {response_time:.2f} seconds")  # 顯示查詢時間