""" Programmatic Index Creation =========================== Use this script to create an index from a DataFrame without the web interface. Example usage: python create_index.py --input data.csv --sequence-column text Or use programmatically: from create_index import create_index_from_dataframe import pandas as pd df = pd.DataFrame({ 'sequence': ['Hello world', 'Machine learning is great', ...], 'category': ['greeting', 'tech', ...], 'id': [1, 2, ...] }) create_index_from_dataframe(df, sequence_column='sequence') """ import argparse import pickle from pathlib import Path import numpy as np import pandas as pd from pickle import dump, load import tiktoken import faiss import torch.nn as nn from x_transformers import TransformerWrapper, Encoder import torch from tqdm import tqdm # Set device and check available GPUs device = torch.device("cuda" if torch.cuda.is_available() else "cpu") n_gpus = torch.cuda.device_count() print(f"Using device: {device}") print(f"Available GPUs: {n_gpus}") for i in range(n_gpus): print(f" GPU {i}: {torch.cuda.get_device_name(i)}") class GenomicTransformer(nn.Module): def __init__(self, vocab_size=40000, hidden_dim=32, layers=2, heads=3, max_length=6000): super().__init__() self.model = TransformerWrapper( num_tokens=vocab_size, max_seq_len=max_length, attn_layers=Encoder( dim=hidden_dim, depth=layers, heads=heads, rotary_pos_emb=True, attn_orthog_projected_values=True, attn_orthog_projected_values_per_head=True, attn_flash=True ) ) def forward(self, input_ids, return_embeddings=False): logits = self.model(input_ids, return_embeddings=return_embeddings) return logits # Configuration - must match app.py DATA_DIR = Path("data") DATA_DIR.mkdir(exist_ok=True) INDEX_PATH = DATA_DIR / "faiss.index" METADATA_PATH = DATA_DIR / "metadata.pkl" EMBEDDINGS_PATH = DATA_DIR / "embeddings.npy" EMBEDDING_MODEL = "all-MiniLM-L6-v2" pattern = load(open("/user/hassanahmed.hassan/u21055/.project/dir.project/towards_better_genomic_models/data/tokenizer_components_bpe_with_repeats.pkl", "rb"))['pattern'] mergable_ranks = load(open("/user/hassanahmed.hassan/u21055/.project/dir.project/towards_better_genomic_models/data/tokenizer_components_bpe_with_repeats.pkl", "rb"))['mergable_ranks'] recreated_enc = tiktoken.Encoding( name="genomic_bpe_recreated", pat_str=pattern, mergeable_ranks=mergable_ranks, special_tokens={} ) # Initialize model MODEL = GenomicTransformer( vocab_size=40_000, hidden_dim=512, layers=12, heads=8 ) # Wrap with DataParallel if multiple GPUs available if n_gpus > 1: print(f"Using DataParallel across {n_gpus} GPUs") MODEL = nn.DataParallel(MODEL) MODEL = MODEL.to(device) MODEL.eval() def create_index_from_dataframe( df: pd.DataFrame, sequence_column: str = "sequence", model=MODEL, encoder=recreated_enc, batch_size: int = 8 # Increased batch size for multi-GPU ) -> dict: """ Create a FAISS index from a pandas DataFrame. Args: df: DataFrame containing sequences and metadata sequence_column: Name of the column containing text sequences model: The transformer model to use encoder: The tokenizer/encoder batch_size: Batch size for encoding (increase for multi-GPU) Returns: dict with index statistics """ if sequence_column not in df.columns: raise ValueError(f"Column '{sequence_column}' not found. Available: {list(df.columns)}") # Get sequences sequences = df[sequence_column].astype(str).tolist()[:10] df = df.iloc[:10].copy() df["__sequence__"] = sequences # Create embeddings print(f"Creating embeddings for {len(sequences)} sequences...") encodings = encoder.encode_batch(sequences) embeddings = [] print(f"Total encodings: {len(encodings)}") # Adjust batch size to be divisible by number of GPUs for efficiency effective_batch_size = batch_size * n_gpus if n_gpus > 1 else batch_size print(f"Using effective batch size: {effective_batch_size}") for i in tqdm(range(0, len(encodings), effective_batch_size)): batch_encodings = encodings[i:i+effective_batch_size] # pad to max length in batch max_len = max(len(enc) for enc in batch_encodings) batch_encodings = [enc + [0]*(max_len - len(enc)) for enc in batch_encodings] # Move tensor to GPU batch_tensor = torch.tensor(batch_encodings).long().to(device) print(f"Batch tensor shape: {batch_tensor.shape}") print(f"Sample batch tensor: {batch_tensor[0][:10]}") with torch.no_grad(): print("Generating embeddings...") batch_embeddings = model(batch_tensor, return_embeddings=True) print(f"Raw batch embeddings shape: {batch_embeddings.shape}") # Move back to CPU for numpy conversion batch_embeddings = batch_embeddings.mean(dim=1).cpu().numpy().tolist() print(f"Batch embeddings shape: {np.array(batch_embeddings).shape}") if i == 0: embeddings = batch_embeddings else: embeddings = embeddings + batch_embeddings embeddings = np.array(embeddings) embeddings = embeddings.astype(np.float32) # Create FAISS index dimension = embeddings.shape[1] index = faiss.IndexFlatIP(dimension) # Inner product = cosine sim for normalized vectors index.add(embeddings) # Save everything print("Saving index to disk...") faiss.write_index(index, str(INDEX_PATH)) with open(METADATA_PATH, "wb") as f: pickle.dump(df, f) np.save(EMBEDDINGS_PATH, embeddings) stats = { "documents_indexed": index.ntotal, "embedding_dimension": dimension, "model": 'MODEL', "index_path": str(INDEX_PATH), "metadata_path": str(METADATA_PATH), "gpus_used": n_gpus } print(f"Index created successfully!") print(f" - Documents: {stats['documents_indexed']}") print(f" - Dimensions: {stats['embedding_dimension']}") print(f" - GPUs used: {stats['gpus_used']}") return stats def search_index( query: str, top_k: int = 10, model=MODEL, encoder=recreated_enc ) -> list[dict]: """ Search the index for similar sequences. """ if not INDEX_PATH.exists(): raise FileNotFoundError("No index found. Create one first with create_index_from_dataframe()") # Load resources index = faiss.read_index(str(INDEX_PATH)) with open(METADATA_PATH, "rb") as f: metadata = pickle.load(f) # Encode query encodings = encoder.encode_ordinary(query) query_tensor = torch.tensor([encodings]).long().to(device) with torch.no_grad(): query_embedding = model(query_tensor, return_embeddings=True).mean(dim=1).cpu().numpy() query_embedding = query_embedding.astype(np.float32) # Search k = min(top_k, index.ntotal) scores, indices = index.search(query_embedding, k) # Build results results = [] for score, idx in zip(scores[0], indices[0]): if idx == -1: continue row = metadata.iloc[idx].to_dict() sequence = row.pop("__sequence__", "") results.append({ "score": float(score), "sequence": sequence, "metadata": row }) return results def main(): parser = argparse.ArgumentParser(description="Create semantic search index from CSV") parser.add_argument("--sequence-column", "-c", default="seq_with_repeat_tokens", help="Column containing sequences") parser.add_argument("--batch-size", "-b", type=int, default=8, help="Batch size per GPU") args = parser.parse_args() df = pd.read_parquet("/user/hassanahmed.hassan/u21055/.project/dir.project/towards_better_genomic_models/data/sample.parquet") print(f"Loaded {len(df)} rows with columns: {list(df.columns)}") create_index_from_dataframe(df, args.sequence_column, MODEL, recreated_enc, batch_size=args.batch_size) if __name__ == "__main__": main()