First version of the dataset

README.md

@@ -0,0 +1,51 @@
+---
+language:
+- en
+pretty_name: Geo Coordinate Augmented Google-Landmarks
+task_categories:
+- image-classification
+source_datasets:
+- Google Landmarks V2
+size_categories:
+- < 50K
+license: cc-by-4.0
+---
+
+
+# Dataset Card for Geo Coordinate Augmented Google-Landmarks
+
+Geo coordinates were added as data to a tar file's worth of images from the [Google Landmark V2](https://github.com/cvdfoundation/google-landmark). Not all of the 
+images could be geo-tagged due to lack of coordinates on the image's wikimedia page. 
+
+## Dataset Details
+
+### Dataset Description
+
+Geo coordinates were added as data to a tar file's worth of images from the [Google Landmark V2](https://github.com/cvdfoundation/google-landmark). There were many more images that could have
+been downloaded but this dataset was found to be a good balance of data size and sample size. 
+
+The intended use for the dataset was to demonstrate using a geo-filter in Qdrant along with a image similarity search. 
+
+Not all of the images couuld be geo-tagged due to lack of coordinates on the image's wikimedia page.
+We provide the raw geotagged file as a geojson document, train_attribution_geo.json. 
+We also provide a json file that includes the data above along with embedding vectors for the images, id_payload_vector.json. 
+
+Thingsvision was used as the library for creating the image embeddings with the following ThingVision model: 
+
+```python
+model_name = 'clip'
+model_parameters = {
+    'variant': 'ViT-B/32'
+}
+```
+
+The code directory contains the Python code used to geotag the images as well as generated the vectors. It can also be used to upload the embeddings to a Qdrant DB instance.  This code is NOT for production and was 
+more focused on quickly and correctly get the coordinates and embed the images. 
+
+The license for this data and code match the license of the original Google Landmarks V2 Dataset: CC BY 4.0 license. 
+
+## Uses
+
+### Direct Use
+
+The primary use is case is image similarity search with geographic filtering. 

code/db_upload.py

@@ -0,0 +1,36 @@
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams
+
+
+class DBUpload:
+
+    def __init__(self, vector_size: int, collection_name: str):
+
+        self.client = QdrantClient(host="localhost", port=6333)
+
+        self.vector_size = vector_size
+        self.collection_name = collection_name
+
+        self.client.recreate_collection(
+            collection_name=collection_name,
+            vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE),
+        )
+
+    def upsert_vectors(self, ids, vectors, payloads):
+        self.client.upload_collection(
+            collection_name=self.collection_name,
+            ids=ids,
+            vectors=vectors,
+            payload=payloads
+        )
+
+    def query_vector(self, vector):
+        print(type(vector))
+        vector = vector[0]
+        search_result = self.client.search(
+            collection_name=self.collection_name,
+            query_vector=vector,
+            limit=5
+
+        )
+        return search_result

code/geojson2qdrnt.py

@@ -0,0 +1,118 @@
+import json
+
+import geojson
+
+# This only accepts simple polygons NOT multipolygons
+# This should actually have 2 methods
+# 1 that returns the JSON needed a REST call
+# 2 one that returns a valid GeoPolygon
+# Maybe they are just static methods on the class and accept a JSON object as input
+
+
+
+def geoJSON2coord_list(geojson_input: geojson):
+    coord_array = geojson_input["geometry"]["coordinates"][0]
+    result_array = []
+    for coord_pair in coord_array:
+        coord_obj = {"lon": coord_pair[0], "lat": coord_pair[1]}
+        result_array.append(coord_obj)
+    return result_array
+
+
+def geoJSON_string2qjson(geojson_input: geojson):
+
+    coord_array = geoJSON2coord_list((geojson_input))
+    poly_filter = {"filter": {"must": [{"geo_polygon": {"exterior": {"points": coord_array}}}]}}
+    return json.dumps(poly_filter)
+    print("should be done")
+
+
+def geoJSON_string2qgeom(geojson_input: geojson):
+    coord_array = geoJSON2coord_list((geojson_input))
+    print("not yet")
+
+if __name__ == '__main__':
+    with open("../germany.geojson", "r", encoding='utf_8') as content:
+        print(geoJSON_string2qjson(json.load(content)))
+
+
+
+# "geo_polygon": {
+#     "exterior": {
+#         "points": [
+#             { "lon": -70.0, "lat": -70.0 },
+#             { "lon": 60.0, "lat": -70.0 },
+#             { "lon": 60.0, "lat": 60.0 },
+#             { "lon": -70.0, "lat": 60.0 },
+#             { "lon": -70.0, "lat": -70.0 }
+#         ]
+#     },
+#     "interiors": [
+#         {
+#             "points": [
+#                 { "lon": -65.0, "lat": -65.0 },
+#                 { "lon": 0.0, "lat": -65.0 },
+#                 { "lon": 0.0, "lat": 0.0 },
+#                 { "lon": -65.0, "lat": 0.0 },
+#                 { "lon": -65.0, "lat": -65.0 }
+#             ]
+#         }
+#     ]
+# }
+
+
+# models.FieldCondition(
+#     key="location",
+#     geo_polygon=models.GeoPolygon(
+#         exterior=models.GeoLineString(
+#             points=[
+#                 models.GeoPoint(
+#                     lon=-70.0,
+#                     lat=-70.0,
+#                 ),
+#                 models.GeoPoint(
+#                     lon=60.0,
+#                     lat=-70.0,
+#                 ),
+#                 models.GeoPoint(
+#                     lon=60.0,
+#                     lat=60.0,
+#                 ),
+#                 models.GeoPoint(
+#                     lon=-70.0,
+#                     lat=60.0,
+#                 ),
+#                 models.GeoPoint(
+#                     lon=-70.0,
+#                     lat=-70.0,
+#                 )
+#             ]
+#         ),
+#         interiors=[
+#             models.GeoLineString(
+#                 points=[
+#                     models.GeoPoint(
+#                         lon=-65.0,
+#                         lat=-65.0,
+#                     ),
+#                     models.GeoPoint(
+#                         lon=0.0,
+#                         lat=-65.0,
+#                     ),
+#                     models.GeoPoint(
+#                         lon=0.0,
+#                         lat=0.0,
+#                     ),
+#                     models.GeoPoint(
+#                         lon=-65.0,
+#                         lat=0.0,
+#                     ),
+#                     models.GeoPoint(
+#                         lon=-65.0,
+#                         lat=-65.0,
+#                     )
+#                 ]
+#             )
+#         ]
+#     )
+# )

code/main.py

@@ -0,0 +1,77 @@
+import requests
+from bs4 import BeautifulSoup
+
+from csv import DictReader
+from pathlib import Path
+import re
+import uuid
+import json
+
+import db_upload
+import make_embeddings_upload
+
+#TODO this is definitely not efficient as it generates vectors for all the images, not just the ones with geo
+# to fix we would somehow copy all the original images in the payloads_non_list into the directory we want to use in the vector making
+
+#TODO there is also repeated code everywhere
+# And hard coded values for too many things
+
+image_path = Path("../images_000")
+
+metadata_path = "../train_attribution.csv"
+image_names = {}
+
+for path in image_path.rglob('*.*'):
+    match = re.search('.*(\w{16})\.jpg$', str(path))
+    image_names[match.group(1)] = path
+
+csvfile = open(metadata_path, "r", encoding='utf-8')
+csvlines = DictReader(csvfile)
+
+payloads_non_list = {}
+i= 1
+for line in csvlines:
+    if line['id'] in image_names:
+        try:
+            page = requests.get(line['url'])
+            html = BeautifulSoup(page.text, features="html.parser")
+            our_tag = html.find('a', {"data-style": "osm-intl"})
+            if our_tag is not None:
+                if "data-lat" in our_tag.attrs and "data-lon" in our_tag.attrs:
+                    lat = float(our_tag.attrs["data-lat"])
+                    lon = float(our_tag.attrs["data-lon"])
+
+                # We have our payload at this point
+                    print("found one " + line['id'] + " : " + line['url'] + " coords: " + str(lat) + ", " + str(lon))
+                    payloads_non_list[line['id']] = {"picture": line['id'], "filename": str(image_names[line['id']]), "url": line['url'], "location": {"lon": lon, "lat": lat}}
+        except:
+            print("Threw an exception on: " + line['id'])
+
+
+csvfile.close()
+# Write our payloads out to file
+
+with open('../train_attribution_geo.json', 'w') as out_file:
+    json.dump(payloads_non_list, out_file, sort_keys=True, indent=4,
+              ensure_ascii=False)
+
+# now create our vector
+vectors_non_list = make_embeddings_upload.get_features()
+
+ids, vectors, payloads = [], [], []
+# Put them together - need to do this because of the sorting problem - need to get them to line up
+for key, payload in payloads_non_list.items():
+    payloads.append(payload)
+    vectors.append(vectors_non_list[key])
+    ids.append(str(uuid.uuid3(uuid.NAMESPACE_DNS,payload["url"])))
+
+# now insert into the collection
+uploader = db_upload.DBUpload(512, "images")
+
+uploader.upsert_vectors(ids, vectors, payloads)
+
+print("finished")
+
+
+
+

code/make_embeddings_upload.py

@@ -0,0 +1,76 @@
+import numpy as np
+import torch
+from thingsvision import get_extractor
+from thingsvision.utils.storing import save_features
+from thingsvision.utils.data import ImageDataset, DataLoader
+
+source = 'custom'
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+model_name = 'clip'
+model_parameters = {
+    'variant': 'ViT-B/32'
+    # This model creates 512 length vectors
+}
+
+# This model is more accurate but takes longer to run and not sure we need it for the demo
+# model_name = 'OpenCLIP'
+# model_parameters = {
+#     'variant': 'ViT-H-14',
+#     'dataset': 'laion2b_s32b_b79k'
+#     # This model create 1024 length vectors
+# }
+
+extractor = get_extractor(
+    model_name=model_name,
+    source=source,
+    device=device,
+    pretrained=True,
+    model_parameters=model_parameters,
+)
+
+root='../images_000/' # (e.g., './images/)
+batch_size = 32
+
+dataset = ImageDataset(
+    root=root,
+    out_path='../test_vectors',
+    backend=extractor.get_backend(), # backend framework of model
+    transforms=extractor.get_transformations(resize_dim=256, crop_dim=224) # set the input dimensionality to whichever values are required for your pretrained model
+)
+
+batches = DataLoader(
+    dataset=dataset,
+    batch_size=batch_size,
+    backend=extractor.get_backend() # backend framework of model
+)
+
+
+module_name = 'visual'
+
+def get_features():
+    # we are creating 512 length vectors
+    features = extractor.extract_features(
+        batches=batches,
+        module_name=module_name,
+        flatten_acts=True,
+        output_type="ndarray", # or "tensor" (only applicable to PyTorch models of which CLIP is one!)
+    )
+
+    # WE ARE NOT DOING THIS append the file names to the front of the vector matrix.  We turn the file names into a 40 x 1
+    # np array #full_data = np.hstack((np.array(dataset.file_names).reshape(-1,1), features))
+    # The model returns the vectors in alphbetical order for the filenames. Our other code just reads through the directory
+    # without a sort.  Therefore this needs to be a dict so we can do lookups
+
+    # save_features(features, out_path='../test_vectors', file_format='txt') # file_format can be set to "npy", "txt", "mat", "pt", or "hdf5"
+
+    vectors = {}
+    for i in range(len(dataset.file_names)):
+        vectors[dataset.file_names[i][0:16]] = features[i]
+
+    return vectors
+
+
+if __name__ == '__main__':
+    result = get_features()
+    print(str(len(result)))
+

code/payload2geojson.py

@@ -0,0 +1,27 @@
+# >>> Feature(geometry=my_point, id=27)  # doctest: +ELLIPSIS
+# {"geometry": {"coordinates": [-3.68..., 40.4...], "type": "Point"}, "id": 27, "properties": {}, "type": "Feature"}
+import json
+from decimal import Decimal
+
+import geojson
+from geojson import Feature, Point
+from qdrant_client.conversions.conversion import payload_to_grpc
+
+geojson_array = []
+
+
+# Load the payload JSON
+with open("D:\data\google-landmarks\geo-google-landmark-payload.json") as jf:
+    input_json = json.load(jf)
+
+    # Now iterate through and make an array of features
+    for id, payload in input_json.items():
+        lon = float(payload["location"]["lon"])
+        lat = float(payload["location"]["lat"])
+        my_point = Point((lon, lat))
+        geojson_array.append(Feature(geometry=my_point, id=payload["picture"], properties={"url": payload["url"]}))
+
+with open("D:\data\google-landmarks\geo-google-landmark.geojson", "w") as output:
+    geojson.dump(geojson_array, fp=output)
+
+print("finished")

code/requirements.txt

@@ -0,0 +1,79 @@
+hpack~=4.0.0
+hyperframe~=6.0.1
+h2~=4.1.0
+beautifulsoup4~=4.12.2
+soupsieve~=2.5
+h11~=0.14.0
+Pillow~=10.0.1
+pip~=21.3.1
+wheel~=0.41.2
+rsa~=4.9
+pyasn1~=0.5.0
+torch~=1.13.1
+torchvision~=0.14.1
+tqdm~=4.66.1
+numpy~=1.25.2
+clip~=1.0
+ftfy~=6.1.1
+regex~=2023.8.8
+wcwidth~=0.2.7
+gast~=0.4.0
+h5py~=3.9.0
+pytz~=2023.3.post1
+scipy~=1.11.3
+matplotlib~=3.8.0
+tensorflow~=2.9.3
+timm~=0.6.13
+requests~=2.31.0
+keras~=2.9.0
+colorama~=0.4.5
+exceptiongroup~=1.1.3
+sniffio~=1.3.0
+click~=8.1.3
+httpcore~=0.18.0
+idna~=3.4
+certifi~=2023.7.22
+pywin32~=306
+six~=1.16.0
+pandas~=2.1.1
+wrapt~=1.14.1
+numba~=0.58.0
+llvmlite~=0.41.0
+PyYAML~=6.0
+setuptools~=68.2.2
+Jinja2~=3.1.2
+thingsvision~=2.4.1
+imageio~=2.31.4
+scikit-image~=0.21.0
+astunparse~=1.6.3
+tensorboard~=2.14.1
+urllib3~=2.0.6
+fsspec~=2023.9.2
+cachetools~=5.3.1
+packaging~=23.2
+joblib~=1.3.2
+MarkupSafe~=2.1.3
+python-dateutil~=2.8.2
+tifffile~=2023.9.26
+networkx~=3.1
+scikit-learn~=1.3.1
+threadpoolctl~=3.2.0
+anyio~=4.0.0
+Markdown~=3.4.4
+oauthlib~=3.2.2
+pydantic~=2.4.2
+werkzeug~=3.0.0
+contourpy~=1.1.1
+fonttools~=4.43.0
+termcolor~=2.3.0
+typeguard~=4.1.5
+cycler~=0.12.0
+pyparsing~=3.0.9
+kiwisolver~=1.4.5
+zipp~=3.17.0
+torchtyping~=0.1.4
+httpx~=0.25.0
+portalocker~=2.8.2
+filelock~=3.12.4
+geojson~=3.0.1
+flatbuffers~=1.12

id_payload_vector.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:699c647604a5831eab3be0b83bf00061798052084249dd798c922e1ffd5906a1
+size 58657241

original_download.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6948e4c06fc0e828699519644f51c6eb570df7a58ae3484f529d2a25a3581585
+size 1569291364

train_attribution_geo.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fd75935c26bc1f5802705a1faaa283c9148261d01df6d2ed5fa093b9f1f5fc9
+size 1121106