Fix: Embeddings file ordering

images.fbin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:16f635d1f477649283707e704c32dc1d54b7a4e3ae560b6da7c0330bd655ee1e
+oid sha256:6e673d5acf7f4a30f67b91d2cd3fcec73ed9b8891c61c22a3e4cda053ba8c7b6
 size 24875016

main.py

@@ -1,72 +1,233 @@
-#!/usr/bin/env python3
-from os import listdir, path, PathLike, remove
-from os.path import isfile, join, exists
+import io
+import os
+import base64
+import mimetypes
 
-import pandas as pd
 import numpy as np
-from PIL import Image
-from PIL import ImageFile
-from tqdm import tqdm
+import streamlit as st
+import pandas as pd
+import altair as alt
+import sklearn as skl
+import PIL as pil
 
 from uform import get_model
 from usearch.index import Index, MetricKind
-from usearch.io import save_matrix, load_matrix
 
-ImageFile.LOAD_TRUNCATED_IMAGES = True
+# Managing data
 
+script_path: str = os.path.dirname(os.path.abspath(__file__))
 
-def is_image(path: PathLike) -> bool:
-    if not isfile(path):
-        return False
-    try:
-        Image.open(path)
-        return True
-    except Exception:
-        return False
+data_path: str = os.environ.get(
+    'UNSPLASH_SEARCH_PATH', os.path.join(script_path, 'dataset'))
 
+view_local_images: bool = True if os.environ.get(
+    'STREAMLIT_SERVER_ENABLE_STATIC_SERVING') else False
 
-def trim_extension(filename: str) -> str:
-    return filename.rsplit('.', 1)[0]
 
+image_query = bytes()
+text_query = str()
+results = list()
+max_caption_length: int = 100
 
-names = sorted(f for f in listdir('images') if is_image(join('images', f)))
-names = [trim_extension(f) for f in names]
 
-table = pd.read_table('images.tsv') if path.exists(
-    'images.tsv') else pd.read_table('images.csv')
-table = table[table['photo_id'].isin(names)]
-table = table.sort_values('photo_id')
-table.reset_index()
-table.to_csv('images.csv', index=False)
+class FileNotFoundError(Exception):
+    pass
 
-names = list(set(table['photo_id']).intersection(names))
-names_to_delete = [f for f in listdir(
-    'images') if trim_extension(f) not in names]
 
-if len(names_to_delete) > 0:
-    print(f'Plans to delete: {len(names_to_delete)} images without metadata')
-    for name in names_to_delete:
-        remove(join('images', name))
+def img_to_data(path):
+    """Convert a file (specified by a path) into a data URI."""
+    if not os.path.exists(path):
+        raise FileNotFoundError
+    mime, _ = mimetypes.guess_type(path)
+    with open(path, 'rb') as fp:
+        data = fp.read()
+        data64 = base64.b64encode(data).decode('utf-8')
+        return f'data:{mime}/jpg;base64,{data64}'
 
-if not exists('images.fbin'):
-    model = get_model('unum-cloud/uform-vl-english')
-    vectors = []
 
-    for name in tqdm(names, desc='Vectorizing images'):
-        image = Image.open(join('images', name + '.jpg'))
-        image_data = model.preprocess_image(image)
-        image_embedding = model.encode_image(image_data).detach().numpy()
-        vectors.append(image_embedding)
+@st.cache_resource
+def get_uform_model():
+    return get_model('unum-cloud/uform-vl-english')
 
-    image_mat = np.concatenate(vectors)
-    save_matrix(image_mat, 'images.fbin')
 
-if not exists('images.usearch'):
-    index = Index(ndim=256, metric=MetricKind.Cos)
-    image_mat = load_matrix('images.fbin')
-    count = image_mat.shape[0]
+@st.cache_resource
+def get_unsplash_metadata():
+    path = os.path.join(data_path, 'images.csv')
+    assert os.path.exists(path), 'Missing metadata file'
+    df = pd.read_csv(path, dtype=str).fillna('')
+    df['photo_submitted_at'] = pd.to_datetime(
+        df['photo_submitted_at'], format='mixed')
+    return df
 
-    for idx in tqdm(range(count), desc='Indexing vectors'):
-        index.add(idx, image_mat[idx, :].flatten())
 
-    index.save('images.usearch')
+@st.cache_resource
+def get_unsplash_usearch_index():
+    index = Index(ndim=256, metric=MetricKind.Cos)
+    path = os.path.join(data_path, 'images.usearch')
+    assert os.path.exists(path), 'Missing index file'
+    index.view(path)
+    return index
+
+
+# GUI setup
+
+st.set_page_config(
+    page_title='USearch through Unsplash',
+    page_icon='🐍', layout='wide',
+    initial_sidebar_state='collapsed',
+)
+
+st.title('USearch through Unsplash')
+
+
+text_query: str = st.text_input(
+    'Search Bar',
+    placeholder='Search for Unsplash photos',
+    value='', key='text_query',
+    label_visibility='collapsed')
+if not len(text_query):
+    text_query = None
+
+image_query: io.BytesIO = st.file_uploader(
+    'Alternatively, choose an image file')
+
+layout: str = st.radio(
+    'Layout',
+    ('List', 'Grid', 'Semantics'),
+    horizontal=True,
+    label_visibility='collapsed')
+
+columns: int = st.sidebar.slider(
+    'Grid Columns', min_value=1, max_value=10, value=5)
+show_captions: bool = st.sidebar.checkbox('Show Captions in Grid', value=True)
+max_results: int = st.sidebar.number_input(
+    'Max Matches', min_value=1, max_value=None, value=100)
+
+model = get_uform_model()
+table = get_unsplash_metadata()
+index = get_unsplash_usearch_index()
+
+# Search Content
+
+if not text_query and not image_query:
+    results = table[:max_results]
+
+else:
+    with st.spinner(f'We are searching through {len(table)} entries'):
+
+        if image_query:
+            image_query = pil.Image.open(image_query)
+            query_data = model.preprocess_image(image_query)
+            query_embedding = model.encode_image(query_data).detach().numpy()
+        else:
+            query_data = model.preprocess_text(text_query)
+            query_embedding = model.encode_text(query_data).detach().numpy()
+
+        # We don't need the text-based search, if we have AI :)
+        # results = table[table['photo_description'].str.contains(
+        #     text_query)][:max_results]
+        matches, _, _ = index.search(
+            query_embedding.flatten(),
+            max_results,
+            exact=True,
+        )
+        results = table.iloc[matches]
+
+    st.success(
+        f'Found {len(results)} matches among {len(table)} entries!', icon='✅')
+
+
+# Join metadata with images
+
+results = results.copy().reset_index()
+results['photo_image_base64'] = [
+    img_to_data(os.path.join(data_path, 'images', id + '.jpg'))
+    for id in results['photo_id']]
+
+
+# Visualize Matches
+
+if layout == 'List':
+
+    columns = [
+        'photo_image_base64',
+        'photo_description',
+        'ai_description',
+        'photographer_username',
+        'photo_submitted_at',
+        'stats_views',
+        'stats_downloads',
+        'photo_id',
+        'photo_url',
+        'photo_image_url',
+    ]
+    visible_results = results[columns]
+
+    st.dataframe(
+        visible_results,
+        column_config={
+            'photo_id': st.column_config.TextColumn('ID'),
+            'photo_url': st.column_config.LinkColumn('Page'),
+            'photo_image_url': st.column_config.LinkColumn('Remote'),
+            'photo_image_base64': st.column_config.ImageColumn(
+                'Local',
+                width='large'),
+            'photo_submitted_at': st.column_config.DatetimeColumn(
+                'Time',
+                format='DD.MM.YYYY',
+            ),
+            'photo_description': st.column_config.TextColumn('Human Text'),
+            'ai_description': st.column_config.TextColumn('AI Text'),
+            'photographer_username': st.column_config.TextColumn('Author'),
+            'stats_views': st.column_config.NumberColumn('Views'),
+            'stats_downloads': st.column_config.NumberColumn('Downloads'),
+        },
+        use_container_width=True,
+        hide_index=False,
+        height=1000,
+    )
+
+elif layout == 'Semantics':
+
+    vectors = np.vstack([
+        index.reconstruct(id, dtype=np.float32)
+        for id in results['photo_id']])
+
+    tsne = skl.manifold.TSNE(
+        n_components=2, learning_rate='auto',
+        init='random', perplexity=3).fit_transform(vectors)
+
+    results['x'] = tsne[:, 0]
+    results['y'] = tsne[:, 1]
+
+    altair_chart = alt.Chart(results).mark_circle(size=200).encode(
+        x='x',
+        y='y',
+        tooltip=['photo_image_base64'],
+    )
+    st.altair_chart(altair_chart, use_container_width=True, theme='streamlit')
+
+elif layout == 'Grid':
+
+    for n_row, row in results.reset_index().iterrows():
+        i = n_row % columns
+        if i == 0:
+            st.write('---')
+            cols = st.columns(columns, gap='large')
+
+        with cols[n_row % columns]:
+            id = row['photo_id']
+            username = row['photographer_username'].strip()
+            preview_path = row['photo_image_base64']
+
+            if show_captions:
+                description = row['photo_description'].strip()
+                if len(description) > max_caption_length:
+                    description = description[:max_caption_length] + '...'
+                description = f'{description} \@{username}'
+            else:
+                description = ''
+            st.image(
+                preview_path,
+                caption=description,
+                use_column_width='always')