Upload 14 files

src/.env

@@ -0,0 +1,3 @@
+CLOUD_NAME=dmiu2ccxh
+API_KEY=681379735874788
+API_SECRET=yyEZbsOBe8j9XsBWoYsA2qpHu_I

src/README.md

@@ -0,0 +1,6 @@
+to see tables:
+
+sqlite3
+
+- pip install tabulate
+- python db_test.py

src/build_gallery_embeddings.py

@@ -0,0 +1,35 @@
+# build_gallery_embeddings.py
+from transformers import CLIPProcessor, CLIPModel
+from PIL import Image
+import torch
+import os
+import pickle
+
+gallery_dir = "gallery"
+embedding_file = "gallery_embeddings.pkl"
+
+model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
+processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+
+embeddings = []
+
+for fname in os.listdir(gallery_dir):
+    if fname.endswith(('.jpg', '.jpeg', '.png')):
+        img_path = os.path.join(gallery_dir, fname)
+        image = Image.open(img_path).convert("RGB")
+
+        inputs = processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            image_emb = model.get_image_features(**inputs)
+        image_emb = image_emb / image_emb.norm(p=2, dim=-1)  # normalize
+
+        embeddings.append({
+            "filename": fname,
+            "embedding": image_emb.squeeze().cpu()
+        })
+
+# Save embeddings
+with open(embedding_file, "wb") as f:
+    pickle.dump(embeddings, f)
+
+print(f"Saved {len(embeddings)} image embeddings.")

src/cloudinary_utils.py

@@ -0,0 +1,16 @@
+import os
+from dotenv import load_dotenv
+import cloudinary
+import cloudinary.uploader
+
+load_dotenv()
+
+cloudinary.config(
+    cloud_name=os.getenv("CLOUD_NAME"),
+    api_key=os.getenv("API_KEY"),
+    api_secret=os.getenv("API_SECRET"),
+)
+
+def upload_to_cloudinary(filepath):
+    response = cloudinary.uploader.upload(filepath)
+    return response.get("secure_url")

src/curato_api.py

@@ -0,0 +1,24 @@
+from flask import Flask, jsonify
+import sqlite3
+
+app = Flask(__name__)
+
+DATABASE = r'C:\Users\sanjana\Desktop\curato\curato.db'
+
+def get_db_connection():
+    conn = sqlite3.connect(DATABASE)
+    conn.row_factory = sqlite3.Row  # To access columns by name
+    return conn
+
+@app.route('/artworks', methods=['GET'])
+def get_artworks():
+    conn = get_db_connection()
+    cursor = conn.execute('SELECT * FROM artworks')  # replace 'artworks' with your table name
+    rows = cursor.fetchall()
+    conn.close()
+
+    artworks = [dict(row) for row in rows]
+    return jsonify(artworks)
+
+if __name__ == '__main__':
+    app.run(debug=True)

src/db_sqlite.py

@@ -0,0 +1,34 @@
+import sqlite3
+
+def init_db():
+    conn = sqlite3.connect("curato.db")
+    cursor = conn.cursor()
+
+    # Create table if it doesn't exist
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS artworks (
+            filename TEXT PRIMARY KEY,
+            style TEXT,
+            tags TEXT,
+            caption TEXT
+        )
+    """)
+
+    # Add cloud_url column if not exists
+    cursor.execute("PRAGMA table_info(artworks)")
+    columns = [col[1] for col in cursor.fetchall()]
+    if 'cloud_url' not in columns:
+        cursor.execute("ALTER TABLE artworks ADD COLUMN cloud_url TEXT")
+
+    conn.commit()
+    conn.close()
+
+def save_metadata(filename, style, tags, caption, cloud_url):
+    conn = sqlite3.connect("curato.db")
+    cursor = conn.cursor()
+    cursor.execute("""
+        INSERT OR REPLACE INTO artworks (filename, style, tags, caption, cloud_url)
+        VALUES (?, ?, ?, ?, ?)
+    """, (filename, style, ",".join(tags), caption, cloud_url))
+    conn.commit()
+    conn.close()

src/db_test.py

@@ -0,0 +1,37 @@
+import sqlite3
+from tabulate import tabulate  # for pretty table output, optional
+
+# Connect to your SQLite DB (change the path accordingly)
+conn = sqlite3.connect(r'C:\Users\sanjana\Desktop\curato\curato.db')
+cursor = conn.cursor()
+
+# 1. List all tables
+cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+tables = cursor.fetchall()
+print("Tables in the database:")
+for table_name in tables:
+    print("-", table_name[0])
+
+# Replace with your actual table name
+table_to_show = tables[0][0]  # Just pick the first table for demo
+
+print(f"\nShowing schema for table '{table_to_show}':")
+cursor.execute(f"PRAGMA table_info({table_to_show})")
+columns = cursor.fetchall()
+for col in columns:
+    print(f"Column: {col[1]}, Type: {col[2]}")
+
+print(f"\nAll data from table '{table_to_show}':")
+cursor.execute(f"SELECT * FROM {table_to_show}")
+rows = cursor.fetchall()
+
+# Print rows in a nice table format (requires tabulate)
+try:
+    print(tabulate(rows, headers=[col[1] for col in columns], tablefmt="grid"))
+except ImportError:
+    # If tabulate is not installed, print raw rows and headers
+    print([col[1] for col in columns])
+    for row in rows:
+        print(row)
+
+conn.close()

src/gallery_embeddings.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:193936530b98c1d7cd49ee06cea454b7ec472b360da56e165bd388f0b0e3f3f6
+size 40099

src/requirements.txt

@@ -0,0 +1,9 @@
+torch
+torchvision
+transformers
+Pillow
+numpy
+scikit-learn
+streamlit
+cloudinary
+ 

src/search.py

@@ -0,0 +1,29 @@
+# search.py
+import torch
+import pickle
+from transformers import CLIPProcessor, CLIPModel
+from PIL import Image
+
+# Load model once
+model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
+processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+
+# Load saved gallery
+with open("gallery_embeddings.pkl", "rb") as f:
+    GALLERY = pickle.load(f)
+
+def find_similar_images(query_image_path, top_k=5):
+    image = Image.open(query_image_path).convert("RGB")
+    inputs = processor(images=image, return_tensors="pt")
+    with torch.no_grad():
+        query_emb = model.get_image_features(**inputs)
+    query_emb = query_emb / query_emb.norm(p=2, dim=-1)
+
+    similarities = []
+    for item in GALLERY:
+        gallery_emb = item["embedding"]
+        score = torch.nn.functional.cosine_similarity(query_emb, gallery_emb.unsqueeze(0)).item()
+        similarities.append((item["filename"], score))
+
+    top_matches = sorted(similarities, key=lambda x: x[1], reverse=True)[:top_k]
+    return top_matches

src/style_classifier.py

@@ -0,0 +1,38 @@
+import os
+import torch
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader
+from torchvision.datasets import ImageFolder
+from torchvision import models
+import torch.nn as nn
+from tqdm import tqdm
+
+ 
+
+ 
+def load_model(model_path="models/style_model.pth", class_names=[]):
+    import torch
+    from torchvision import models
+    model = models.resnet18(pretrained=False)
+    model.fc = torch.nn.Linear(model.fc.in_features, len(class_names))
+    model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
+    model.eval()
+    return model
+
+def predict_style(image_path, model, class_names):
+    from PIL import Image
+    from torchvision import transforms
+    import torch
+
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor()
+    ])
+    image = Image.open(image_path).convert("RGB")
+    image = transform(image).unsqueeze(0)
+
+    with torch.no_grad():
+        output = model(image)
+        _, predicted = torch.max(output, 1)
+    
+    return class_names[predicted.item()]

src/tagger.py

@@ -0,0 +1,30 @@
+from transformers import CLIPProcessor, CLIPModel
+from PIL import Image
+import torch
+
+# Load model + processor
+model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
+processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+
+# Candidate tags
+CANDIDATE_TAGS = [
+    "portrait", "landscape", "abstract", "surreal", "dark", "bright", 
+    "melancholy", "joyful", "blue tones", "warm colors", "minimalist", "detailed"
+]
+
+def generate_tags(image_path):
+    image = Image.open(image_path).convert("RGB")
+    inputs = processor(text=CANDIDATE_TAGS, images=image, return_tensors="pt", padding=True)
+    outputs = model(**inputs)
+
+    logits_per_image = outputs.logits_per_image
+    probs = logits_per_image.softmax(dim=1)
+
+    top_probs, indices = probs.topk(5)
+    tags = [CANDIDATE_TAGS[i] for i in indices[0]]
+
+    return tags
+
+def generate_caption(image_path):
+    # Placeholder caption - replace this with real captioning logic
+    return "This is a placeholder caption."

src/train_style_classifier_hf.py

@@ -0,0 +1,104 @@
+from datasets import load_dataset
+from torchvision import transforms
+from torch.utils.data import Dataset
+from PIL import Image
+
+# Define transform
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225])
+])
+
+# Load HF dataset (use 'test' split because 'train' doesn't exist)
+hf_dataset = load_dataset("asahi417/wikiart-all", split="test")
+
+# Your custom Dataset class
+class WikiArtDataset(Dataset):
+    def __init__(self, hf_dataset, transform=None):
+        self.dataset = hf_dataset
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def __getitem__(self, idx):
+        image = self.dataset[idx]["image"]
+        label = self.dataset[idx]["style"]
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label
+
+# Create PyTorch dataset
+dataset = WikiArtDataset(hf_dataset, transform=transform)
+
+'''from torchvision import datasets, transforms, models
+from torch.utils.data import DataLoader
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from tqdm import tqdm
+import os
+import json
+
+# Styles (should match folder names in data/wikiart_hf_small)
+STYLES = ["Realism", "Cubism", "Impressionism", "Abstract Art"]
+DATA_DIR = "data/wikiart"
+
+# Define transforms
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225])
+])
+
+# Load dataset from folders
+dataset = datasets.ImageFolder(root="data/wikiart", transform=transform)
+
+dataloader = DataLoader(dataset, batch_size=16, shuffle=True)
+
+# Device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load pretrained model
+model = models.resnet18(pretrained=True)
+model.fc = nn.Linear(model.fc.in_features, len(STYLES))
+model.to(device)
+
+# Loss & Optimizer
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=1e-4)
+
+# Train
+model.train()
+for epoch in range(20):
+    running_loss = 0.0
+    for images, labels in tqdm(dataloader, desc=f"Epoch {epoch+1}"):
+        images = images.to(device)
+        labels = labels.to(device)
+
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+        running_loss += loss.item()
+    print(f"Epoch {epoch+1} Loss: {running_loss:.4f}")
+
+# Save model and label map
+os.makedirs("models", exist_ok=True)
+torch.save(model.state_dict(), "models/style_model_hf.pth")
+
+# Save class names
+with open("models/style_classes.json", "w") as f:
+    json.dump(dataset.classes, f)
+
+print("✅ Model saved to models/style_model_hf.pth")
+print("✅ Style classes saved to models/style_classes.json")
+'''