init

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,409 @@
+import streamlit as st
+from PIL import Image
+import torch
+from torchvision import transforms
+import pydeck as pdk
+from geopy.geocoders import Nominatim
+import time
+import requests
+from io import BytesIO
+import reverse_geocoder as rg
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin
+from models.huggingface import Geolocalizer
+import spacy
+from collections import Counter
+from spacy.cli import download
+from typing import Tuple, List, Optional, Union, Dict
+
+
+def load_spacy_model(model_name: str = "en_core_web_md") -> spacy.Language:
+    """
+    Load the specified spaCy model.
+
+    Args:
+        model_name (str): Name of the spaCy model to load.
+
+    Returns:
+        spacy.Language: Loaded spaCy model.
+    """
+    try:
+        return spacy.load(model_name)
+    except IOError:
+        print(f"Model {model_name} not found, downloading...")
+        download(model_name)
+        return spacy.load(model_name)
+
+
+nlp = load_spacy_model()
+
+IMAGE_SIZE = (224, 224)
+GEOLOC_MODEL_NAME = "osv5m/baseline"
+
+
+@st.cache_resource(show_spinner=True)
+def load_geoloc_model() -> Optional[Geolocalizer]:
+    """
+    Load the geolocation model.
+
+    Returns:
+        Optional[Geolocalizer]: Loaded geolocation model or None if loading fails.
+    """
+    with st.spinner('Loading model...'):
+        try:
+            model = Geolocalizer.from_pretrained(GEOLOC_MODEL_NAME)
+            model.eval()
+            return model
+        except Exception as e:
+            st.error(f"Failed to load the model: {e}")
+            return None
+
+
+def most_frequent_locations(text: str) -> Tuple[str, List[str]]:
+    """
+    Find the most frequent locations mentioned in the text.
+
+    Args:
+        text (str): Input text to analyze.
+
+    Returns:
+        Tuple[str, List[str]]: Description of the most mentioned locations and a list of those locations.
+    """
+    doc = nlp(text)
+    locations = []
+
+    for ent in doc.ents:
+        if ent.label_ in ['LOC', 'GPE']:
+            print(f"Entity: {ent.text} | Label: {ent.label_} | Sentence: {ent.sent}")
+            locations.append(ent.text)
+
+    if locations:
+        location_counts = Counter(locations)
+        most_common_locations = location_counts.most_common(2)
+        common_locations_str = ', '.join([f"{loc[0]} ({loc[1]} occurrences)" for loc in most_common_locations])
+        return f"Most Mentioned Locations: {common_locations_str}", [loc[0] for loc in most_common_locations]
+    else:
+        return "No locations found", []
+
+
+def transform_image(image: Image) -> torch.Tensor:
+    """
+    Transform the input image for model prediction.
+
+    Args:
+        image (Image): Input image.
+
+    Returns:
+        torch.Tensor: Transformed image tensor.
+    """
+    transform = transforms.Compose([
+        transforms.Resize(IMAGE_SIZE),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    return transform(image).unsqueeze(0)
+
+
+def check_location_match(location_query: dict, most_common_locations: List[str]) -> bool:
+    """
+    Check if the predicted location matches any of the most common locations.
+
+    Args:
+        location_query (dict): Predicted location details.
+        most_common_locations (List[str]): List of most common locations.
+
+    Returns:
+        bool: True if a match is found, False otherwise.
+    """
+    name = location_query['name']
+    admin1 = location_query['admin1']
+    cc = location_query['cc']
+
+    for loc in most_common_locations:
+        if name in loc and admin1 in loc and cc in loc:
+            return True
+    return False
+
+
+def get_city_geojson(location_name: str) -> Optional[dict]:
+    """
+    Fetch the GeoJSON data for the specified city.
+
+    Args:
+        location_name (str): Name of the city.
+
+    Returns:
+        Optional[dict]: GeoJSON data of the city or None if fetching fails.
+    """
+    geolocator = Nominatim(user_agent="predictGeolocforImage")
+    try:
+        location = geolocator.geocode(location_name, geometry='geojson')
+        return location.raw['geojson'] if location else None
+    except Exception as e:
+        st.error(f"Failed to geocode location: {e}")
+        return None
+
+
+def get_media(url: str) -> Optional[List[Tuple[str, str]]]:
+    """
+    Fetch media URLs and associated text from the specified URL.
+
+    Args:
+        url (str): URL to fetch media from.
+
+    Returns:
+        Optional[List[Tuple[str, str]]]: List of tuples containing media URLs and associated text or None if fetching fails.
+    """
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        data = response.json()
+        return [(media['media_url'], entry['full_text'])
+                for entry in data for media in entry.get('media', []) if 'media_url' in media]
+    except requests.RequestException as e:
+        st.error(f"Failed to fetch media URL: {e}")
+        return None
+
+
+def predict_location(image: Image, model: Geolocalizer) -> Optional[Tuple[List[float], dict, Optional[dict], float]]:
+    """
+    Predict the location from the input image using the specified model.
+
+    Args:
+        image (Image): Input image.
+        model (Geolocalizer): Geolocation model.
+
+    Returns:
+        Optional[Tuple[List[float], dict, Optional[dict], float]]: Predicted GPS coordinates, location query, city GeoJSON data, and processing time or None if prediction fails.
+    """
+    with st.spinner('Processing image and predicting location...'):
+        start_time = time.time()
+        try:
+            img_tensor = transform_image(image)
+            gps_radians = model(img_tensor)
+            gps_degrees = torch.rad2deg(gps_radians).squeeze(0).cpu().tolist()
+            location_query = rg.search((gps_degrees[0], gps_degrees[1]))[0]
+            location_name = f"{location_query['name']}, {location_query['admin1']}, {location_query['cc']}"
+            city_geojson = get_city_geojson(location_name)
+            processing_time = time.time() - start_time
+            return gps_degrees, location_query, city_geojson, processing_time
+        except Exception as e:
+            st.error(f"Failed to predict the location: {e}")
+            return None
+
+
+def display_map(city_geojson: dict, gps_degrees: List[float]) -> None:
+    """
+    Display a map with the specified city GeoJSON data and GPS coordinates.
+
+    Args:
+        city_geojson (dict): GeoJSON data of the city.
+        gps_degrees (List[float]): GPS coordinates.
+    """
+    map_view = pdk.Deck(
+        map_style='mapbox://styles/mapbox/light-v9',
+        initial_view_state=pdk.ViewState(
+            latitude=gps_degrees[0],
+            longitude=gps_degrees[1],
+            zoom=8,
+            pitch=0,
+        ),
+        layers=[
+            pdk.Layer(
+                'GeoJsonLayer',
+                data=city_geojson,
+                get_fill_color=[255, 180, 0, 140],
+                pickable=True,
+                stroked=True,
+                filled=True,
+                extruded=False,
+                line_width_min_pixels=1,
+            ),
+        ],
+    )
+    st.pydeck_chart(map_view)
+
+
+def display_image(image_url: str) -> None:
+    """
+    Display an image from the specified URL.
+
+    Args:
+        image_url (str): URL of the image.
+    """
+    try:
+        response = requests.get(image_url)
+        response.raise_for_status()
+        image_bytes = BytesIO(response.content)
+        st.image(image_bytes, caption=f'Image from URL: {image_url}', use_column_width=True)
+    except requests.RequestException as e:
+        st.error(f"Failed to fetch image at URL {image_url}: {e}")
+    except Exception as e:
+        st.error(f"An error occurred: {e}")
+
+
+def scrape_webpage(url: str) -> Union[Tuple[Optional[str], Optional[List[str]]], Tuple[None, None]]:
+    """
+    Scrape the specified webpage for text and images.
+
+    Args:
+        url (str): URL of the webpage to scrape.
+
+    Returns:
+        Union[Tuple[Optional[str], Optional[List[str]]], Tuple[None, None]]: Extracted text and list of image URLs or None if scraping fails.
+    """
+    with st.spinner('Scraping web page...'):
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.content, 'html.parser')
+            base_url = url  # Adjust based on <base> tags or other HTML clues
+            text = ''.join(p.text for p in soup.find_all('p'))
+            images = [urljoin(base_url, img['src']) for img in soup.find_all('img') if 'src' in img.attrs]
+            return text, images
+        except requests.RequestException as e:
+            st.error(f"Failed to fetch and parse the URL: {e}")
+            return None, None
+
+
+def main() -> None:
+    """
+    Main function to run the Streamlit app.
+    """
+    st.title('Welcome to Geolocation Guesstimation Demo 👋')
+
+    page = st.sidebar.selectbox(
+        "Choose your action:",
+        ("Home", "Images", "Social Media", "Web Pages"),
+        index=0
+    )
+
+    st.sidebar.success("Select a demo above.")
+    st.sidebar.info(
+        """
+        - Web App URL: <https://yunusserhat-guesstimatelocation.hf.space/>
+        """
+    )
+
+    st.sidebar.title("Contact")
+    st.sidebar.info(
+        """
+        Yunus Serhat Bıçakçı at [yunusserhat.com](https://yunusserhat.com) | [GitHub](https://github.com/yunusserhat) | [Twitter](https://twitter.com/yunusserhat) | [LinkedIn](https://www.linkedin.com/in/yunusserhat)
+        """
+    )
+
+    if page == "Home":
+        st.write("Welcome to the Geolocation Predictor. Please select an action from the sidebar dropdown.")
+
+    elif page == "Images":
+        upload_images_page()
+
+    elif page == "Social Media":
+        social_media_page()
+
+    elif page == "Web Pages":
+        web_page_url_page()
+
+
+def upload_images_page() -> None:
+    """
+    Display the image upload page for geolocation prediction.
+    """
+    st.header("Image Upload for Geolocation Prediction")
+    uploaded_files = st.file_uploader("Choose images...", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
+    if uploaded_files:
+        for idx, file in enumerate(uploaded_files, start=1):
+            with st.spinner(f"Processing {file.name}..."):
+                image = Image.open(file).convert('RGB')
+                st.image(image, caption=f'Uploaded Image: {file.name}', use_column_width=True)
+                model = load_geoloc_model()
+                if model:
+                    result = predict_location(image, model)
+                    if result:
+                        gps_degrees, location_query, city_geojson, processing_time = result
+                        st.write(
+                            f"City: {location_query['name']}, Region: {location_query['admin1']}, Country: {location_query['cc']}")
+                        if city_geojson:
+                            display_map(city_geojson, gps_degrees)
+                            st.write(f"Processing Time (seconds): {processing_time}")
+
+
+def social_media_page() -> None:
+    """
+    Display the social media analysis page.
+    """
+    st.header("Social Media Analyser")
+    social_media_url = st.text_input("Enter a social media URL to analyse:", key='social_media_url_input')
+    if social_media_url:
+        media_data = get_media(social_media_url)
+        if media_data:
+            full_text = media_data[0][1]
+            st.subheader("Full Text")
+            st.write(full_text)
+            most_used_location, most_common_locations = most_frequent_locations(full_text)
+            st.subheader("Most Frequent Location")
+            st.write(most_used_location)
+
+            for idx, (media_url, _) in enumerate(media_data, start=1):
+                st.subheader(f"Image {idx}")
+                response = requests.get(media_url)
+                if response.status_code == 200:
+                    image = Image.open(BytesIO(response.content)).convert('RGB')
+                    st.image(image, caption=f'Image from URL: {media_url}', use_column_width=True)
+                    model = load_geoloc_model()
+                    if model:
+                        result = predict_location(image, model)
+                        if result:
+                            gps_degrees, location_query, city_geojson, processing_time = result
+                            location_name = f"{location_query['name']}, {location_query['admin1']}, {location_query['cc']}"
+                            st.write(
+                                f"City: {location_query['name']}, Region: {location_query['admin1']}, Country: {location_query['cc']}")
+                            if city_geojson:
+                                display_map(city_geojson, gps_degrees)
+                                st.write(f"Processing Time (seconds): {processing_time}")
+                            if check_location_match(location_query, most_common_locations):
+                                st.success(
+                                    f"The predicted location {location_name} matches one of the most frequently mentioned locations!")
+                else:
+                    st.error(f"Failed to fetch image at URL {media_url}: HTTP {response.status_code}")
+
+
+def web_page_url_page() -> None:
+    """
+    Display the web page URL analysis page.
+    """
+    st.header("Web Page Analyser")
+    web_page_url = st.text_input("Enter a web page URL to scrape:", key='web_page_url_input')
+    if web_page_url:
+        text, images = scrape_webpage(web_page_url)
+        if text:
+            st.subheader("Extracted Text First 500 Characters:")
+            st.write(text[:500])
+            most_used_location, most_common_locations = most_frequent_locations(text)
+            st.subheader("Most Frequent Location")
+            st.write(most_used_location)
+            if images:
+                selected_image_url = st.selectbox("Select an image to predict location:", images)
+                if selected_image_url:
+                    response = requests.get(selected_image_url)
+                    if response.status_code == 200:
+                        image = Image.open(BytesIO(response.content)).convert('RGB')
+                        st.image(image, caption=f'Selected Image from URL: {selected_image_url}', use_column_width=True)
+                        model = load_geoloc_model()
+                        if model:
+                            result = predict_location(image, model)
+                            if result:
+                                gps_degrees, location_query, city_geojson, processing_time = result
+                                location_name = f"{location_query['name']}, {location_query['admin1']}, {location_query['cc']}"
+                                st.write(
+                                    f"City: {location_query['name']}, Region: {location_query['admin1']}, Country: {location_query['cc']}")
+                                if city_geojson:
+                                    display_map(city_geojson, gps_degrees)
+                                    st.write(f"Processing Time (seconds): {processing_time}")
+                                if check_location_match(location_query, most_common_locations):
+                                    st.success(
+                                        f"The predicted location {location_name} matches one of the most frequently mentioned locations!")
+
+
+if __name__ == '__main__':
+    main()

configs/computer/a100.yaml

@@ -0,0 +1,8 @@
+devices: 1
+progress_bar_refresh_rate: 2
+num_workers: 8
+sync_batchnorm: False
+accelerator: gpu
+precision: 32
+strategy: auto
+num_nodes: 1

configs/computer/cluster-node-a100.yaml

@@ -0,0 +1,8 @@
+devices: 8
+num_workers: 8
+progress_bar_refresh_rate: 2
+sync_batchnorm: True
+accelerator: gpu
+precision: 32
+strategy: ddp
+num_nodes: 1

configs/computer/cluster-node-v100.yaml

@@ -0,0 +1,8 @@
+devices: 4
+num_workers: 10
+progress_bar_refresh_rate: 2
+sync_batchnorm: True
+accelerator: gpu
+precision: 32
+strategy: ddp
+num_nodes: 1

configs/computer/cpu.yaml

@@ -0,0 +1,8 @@
+devices: null
+num_workers: 0
+progress_bar_refresh_rate: 2
+sync_batchnorm: False
+accelerator: cpu
+precision: 32
+strategy: auto
+num_nodes: null

configs/computer/v100.yaml

@@ -0,0 +1,8 @@
+devices: 1
+num_workers: 10
+progress_bar_refresh_rate: 2
+sync_batchnorm: False
+accelerator: gpu
+precision: 32
+strategy: auto
+num_nodes: 1

configs/config.yaml

@@ -0,0 +1,89 @@
+defaults:
+  - model: default
+  - computer: v100
+  - dataset: osv5m
+  - _self_
+  - exp: ???
+
+model:
+  val_metrics:
+    _target_: metrics.distance_based.HaversineMetrics
+    acc_radiuses:
+      - 1
+      - 25
+      - 200
+      - 750
+      - 2500
+    acc_area: []
+    aux_data: ${aux_data}
+  test_metrics:
+    _target_: metrics.distance_based.HaversineMetrics
+    acc_radiuses:
+      - 1
+      - 25
+      - 200
+      - 750
+      - 2500
+    acc_area: ${areas}
+    aux_data: ${aux_data}
+
+datamodule:
+  _target_: data.datamodule.ImageDataModule
+  train_dataset: ${dataset.train_dataset}
+  val_dataset: ${dataset.val_dataset}
+  test_dataset: ${dataset.test_dataset}
+  global_batch_size: ${dataset.global_batch_size}
+  num_workers: ${computer.num_workers}
+  num_nodes: ${computer.num_nodes}
+  num_devices: ${computer.devices}
+  val_proportion: 0.1
+
+trainer:
+  _target_: pytorch_lightning.Trainer
+  devices: ${computer.devices}
+  accelerator: ${computer.accelerator}
+  strategy: ${computer.strategy}
+  num_nodes: ${computer.num_nodes}
+  precision: ${computer.precision}
+  max_epochs: ${max_epochs}
+
+logger:
+  _target_: pytorch_lightning.loggers.WandbLogger
+  save_dir: ${root_dir}
+  name: ${experiment_name}
+  project: plonk
+  log_model: False
+  offline: False
+  entity: imaginelab
+
+checkpoints:
+  _target_: pytorch_lightning.callbacks.ModelCheckpoint
+  dirpath: ${root_dir}/checkpoints/${experiment_name}
+  filename: 'epoch_{epoch}'
+  monitor: val/loss
+  save_last: True
+  save_top_k: 0
+  every_n_epochs: 1
+
+progress_bar:
+  _target_: pytorch_lightning.callbacks.TQDMProgressBar
+  refresh_rate: ${computer.progress_bar_refresh_rate}
+
+aux_data: []
+max_epochs: 100
+data_dir: ${root_dir}/datasets
+root_dir:  ${hydra:runtime.cwd}
+experiment_name: ${dataset.name}__${model.name}
+mode: train # change that to eval to do the testing
+num_classes: 0
+areas: ['country', 'region', 'sub-region', 'city']
+class_name: null
+streetclip: False
+blur: False
+text_tuning: False
+
+hydra:
+  run:
+    dir: outputs/${hydra.job.name}/${now:%Y-%m-%d_%H-%M-%S}/${experiment_name}
+  job:
+    chdir: true

configs/dataset/baselines/im2gps.yaml

@@ -0,0 +1,16 @@
+dataset:
+  name: im2gps
+  global_batch_size: 512
+  test_dataset:
+    _partial_: true
+    _target_: data.data.Baseline
+    path: ${data_dir}/baselines/im2gps
+    which: 'im2gps'
+    transforms: ${dataset.test_transform}
+datamodule:
+  _target_: data.datamodule.BaselineDataModule
+  test_dataset: ${dataset.test_dataset}
+  global_batch_size: ${dataset.global_batch_size}
+  num_workers: ${computer.num_workers}
+  num_nodes: ${computer.num_nodes}
+  num_devices: ${computer.devices}

configs/dataset/baselines/im2gps3k.yaml

@@ -0,0 +1,16 @@
+dataset:
+  name: im2gps3k
+  global_batch_size: 512
+  test_dataset:
+    _partial_: true
+    _target_: data.data.Baseline
+    path: ${data_dir}/baselines/im2gps3k
+    which: 'im2gps3k'
+    transforms: ${dataset.test_transform}
+datamodule:
+  _target_: data.datamodule.BaselineDataModule
+  test_dataset: ${dataset.test_dataset}
+  global_batch_size: ${dataset.global_batch_size}
+  num_workers: ${computer.num_workers}
+  num_nodes: ${computer.num_nodes}
+  num_devices: ${computer.devices}

configs/dataset/baselines/yfcc4k.yaml

@@ -0,0 +1,16 @@
+dataset:
+  name: yfcc4k
+  global_batch_size: 512
+  test_dataset:
+    _partial_: true
+    _target_: data.data.Baseline
+    path: ${data_dir}/baselines/yfcc4k
+    which: 'yfcc4k'
+    transforms: ${dataset.test_transform}
+datamodule:
+  _target_: data.datamodule.BaselineDataModule
+  test_dataset: ${dataset.test_dataset}
+  global_batch_size: ${dataset.global_batch_size}
+  num_workers: ${computer.num_workers}
+  num_nodes: ${computer.num_nodes}
+  num_devices: ${computer.devices}

configs/dataset/osv5m.yaml

@@ -0,0 +1,46 @@
+defaults:
+  - train_transform: fast_clip
+  - test_transform: fast_clip
+  - _self_
+
+name: osv5m
+global_batch_size: 256
+
+train_dataset:
+  _partial_: true
+  _target_: data.data.osv5m
+  path: ${data_dir}/osv5m/
+  split: train
+  class_name: ${class_name}
+  transforms: ${dataset.train_transform}
+  aux_data: ${aux_data}
+  is_baseline: ${is_baseline}
+  areas: ${areas}
+  streetclip: ${streetclip}
+  blur: ${blur}
+
+val_dataset:
+  _partial_: true
+  _target_: data.data.osv5m
+  path: ${data_dir}/osv5m/
+  split: val
+  class_name: ${class_name}
+  transforms: ${dataset.test_transform}
+  aux_data: ${aux_data}
+  is_baseline: ${is_baseline}
+  areas: ${areas}
+  streetclip: ${streetclip}
+  blur: ${blur}
+
+test_dataset:
+  _partial_: true
+  _target_: data.data.osv5m
+  path: ${data_dir}/osv5m/
+  split: test
+  class_name: ${class_name}
+  transforms: ${dataset.test_transform}
+  aux_data: ${aux_data}
+  is_baseline: ${is_baseline}
+  areas: ${areas}
+  streetclip: ${streetclip}
+  blur: ${blur}

configs/dataset/osv5m_contrastive.yaml

@@ -0,0 +1,34 @@
+defaults:
+  - train_transform: fast_clip
+  - test_transform: fast_clip
+  - _self_
+
+name: osv5m
+global_batch_size: 256
+
+train_dataset:
+  _partial_: true
+  _target_: data.data.Contrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: train
+  class_name: ${class_name}
+  transforms: ${dataset.train_transform}
+  blur: ${blur}
+
+val_dataset:
+  _partial_: true
+  _target_: data.data.Contrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: val
+  class_name: ${class_name}
+  transforms: ${dataset.test_transform}
+  blur: ${blur}
+
+test_dataset:
+  _partial_: true
+  _target_: data.data.Contrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: test
+  class_name: ${class_name}
+  transforms: ${dataset.test_transform}
+  blur: ${blur}

configs/dataset/osv5m_contrastive_best.yaml

@@ -0,0 +1,37 @@
+defaults:
+  - train_transform: fast_clip
+  - test_transform: fast_clip
+  - _self_
+
+name: osv5m
+global_batch_size: 256
+
+train_dataset:
+  _partial_: true
+  _target_: data.data.Contrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: train
+  class_name: ${class_name}
+  transforms: ${dataset.train_transform}
+  class_name2: 'unique_region'
+  blur: ${blur}
+
+val_dataset:
+  _partial_: true
+  _target_: data.data.Contrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: val
+  class_name: ${class_name}
+  transforms: ${dataset.test_transform}
+  class_name2: 'unique_region'
+  blur: ${blur}
+
+test_dataset:
+  _partial_: true
+  _target_: data.data.Contrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: test
+  class_name: ${class_name}
+  transforms: ${dataset.test_transform}
+  class_name2: 'unique_region'
+  blur: ${blur}

configs/dataset/osv5m_text_contrastive.yaml

@@ -0,0 +1,34 @@
+defaults:
+  - train_transform: fast_clip
+  - test_transform: fast_clip
+  - _self_
+
+name: osv5m
+global_batch_size: 256
+
+train_dataset:
+  _partial_: true
+  _target_: data.data.TextContrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: train
+  class_name: ${class_name}
+  transforms: ${dataset.train_transform}
+  blur: ${blur}
+
+val_dataset:
+  _partial_: true
+  _target_: data.data.TextContrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: val
+  class_name: ${class_name}
+  transforms: ${dataset.test_transform}
+  blur: ${blur}
+
+test_dataset:
+  _partial_: true
+  _target_: data.data.TextContrastiveosv5m
+  path: ${data_dir}/osv5m/
+  split: test
+  class_name: ${class_name}
+  transforms: ${dataset.test_transform}
+  blur: ${blur}

configs/dataset/test_transform/center_crop.yaml

@@ -0,0 +1,12 @@
+_target_: torchvision.transforms.Compose
+transforms:
+  - _target_: torchvision.transforms.ToTensor
+  - _target_: utils.image_processing.CenterCrop
+    ratio: "1:1"
+  - _target_: torchvision.transforms.Resize
+    size: ${dataset.img_resolution}
+    interpolation: 3
+    antialias: true
+  - _target_: torchvision.transforms.Normalize
+    mean: 0.5
+    std: 0.5

configs/dataset/test_transform/clip.yaml

@@ -0,0 +1,2 @@
+_target_: data.transforms.ClipTransform
+split: val

configs/dataset/test_transform/fast_clip.yaml

@@ -0,0 +1,12 @@
+_target_: torchvision.transforms.Compose
+transforms:
+  - _target_: torchvision.transforms.Resize
+    size: 224
+    interpolation: 3
+    antialias: true
+  - _target_: torchvision.transforms.CenterCrop
+    size: 224
+  - _target_: torchvision.transforms.ToTensor
+  - _target_: torchvision.transforms.Normalize
+    mean: [0.48145466, 0.4578275, 0.40821073]
+    std: [0.26862954, 0.26130258, 0.27577711]

configs/dataset/test_transform/fast_resnet.yaml

@@ -0,0 +1,12 @@
+_target_: torchvision.transforms.Compose
+transforms:
+  - _target_: torchvision.transforms.Resize
+    size: 224
+    interpolation: 3
+    antialias: true
+  - _target_: torchvision.transforms.CenterCrop
+    size: 224
+  - _target_: torchvision.transforms.ToTensor
+  - _target_: torchvision.transforms.Normalize
+    mean: [0.485 ,0.456 ,0.406]
+    std: [0.229, 0.224, 0.225]

configs/dataset/test_transform/none.yaml

@@ -0,0 +1,6 @@
+_target_: torchvision.transforms.Compose
+transforms:
+  - _target_: torchvision.transforms.ToTensor
+  - _target_: torchvision.transforms.Normalize
+    mean: 0.5
+    std: 0.5

configs/dataset/train_transform/augmentation.yaml

@@ -0,0 +1,85 @@
+_target_: data.augmentation.ImageAugmentation
+names: "standard_augmentation,geometric_augmentation,clip_transform"
+
+# always apply clip_transform at the end
+clip_transform:
+  _target_: torchvision.transforms.Compose
+  transforms:
+    - _target_: torchvision.transforms.Resize
+      size: 224
+      interpolation: 3
+      antialias: true
+    - _target_: torchvision.transforms.CenterCrop
+      size: 224
+    - _target_: torchvision.transforms.ToTensor
+    - _target_: torchvision.transforms.Normalize
+      mean: [0.48145466, 0.4578275, 0.40821073]
+      std: [0.26862954, 0.26130258, 0.27577711]
+
+standard_augmentation:
+  _target_: data.augmentation.StandardAugmentation
+  # by default, we all augmentation methods
+  names: "brightness,contrast,sharpness,color,blur,gaussian_noise"
+
+  # random PIL brigtness
+  brightness:
+    _target_: data.augmentation.PillowBrightness
+    p: 0.2
+    factor_interval: [0.5, 1.5]
+
+  # random PIL contrast
+  contrast:
+    _target_: data.augmentation.PillowContrast
+    p: 0.2
+    factor_interval: [0.3, 3]
+
+  # random PIL sharpness
+  sharpness:
+    _target_: data.augmentation.PillowSharpness
+    p: 0.2
+    factor_interval: [0.5, 30.0]
+
+  # random PIL color
+  color:
+    _target_: data.augmentation.PillowColor
+    p: 0.2
+    factor_interval: [0.0, 2.0]
+
+  # random PIL blur
+  blur:
+    _target_: data.augmentation.PillowBlur
+    p: 0.2
+    factor_interval: [1, 2]
+
+  # random numpy gaussian noise
+  gaussian_noise:
+    _target_: data.augmentation.NumpyGaussianNoise
+    p: 0.2
+    factor_interval: [0.1, 0.04]
+
+geometric_augmentation:
+  _target_: data.augmentation.GeometricAugmentation
+  # by default, we all augmentation methods
+  names: "random_rotation,random_resized_crop,random_horizontal_flip"
+
+  # random rotation
+  random_rotation:
+    _target_: torchvision.transforms.RandomRotation
+    degrees: [-15, 15]
+
+  # random crop
+  random_resized_crop:
+    _target_: torchvision.transforms.RandomResizedCrop
+    scale: [0.5, 1.0]
+    ratio: [0.9, 1.1]
+    size: 224
+
+  # random horizontal flip
+  random_horizontal_flip:
+    _target_: torchvision.transforms.RandomHorizontalFlip
+    p: 0.5
+
+  # random vertical flip
+  random_vertical_flip:
+    _target_: torchvision.transforms.RandomVerticalFlip
+    p: 0.5

configs/dataset/train_transform/center_crop.yaml

@@ -0,0 +1,14 @@
+_target_: torchvision.transforms.Compose
+transforms:
+  - _target_: torchvision.transforms.ToTensor
+  - _target_: utils.image_processing.CenterCrop
+    ratio: "1:1"
+  - _target_: torchvision.transforms.Resize
+    size: ${dataset.img_resolution}
+    interpolation: 3
+    antialias: true
+  - _target_: torchvision.transforms.RandomHorizontalFlip
+    p: 0.5
+  - _target_: torchvision.transforms.Normalize
+    mean: 0.5
+    std: 0.5

configs/dataset/train_transform/clip.yaml

@@ -0,0 +1,2 @@
+_target_: data.transforms.ClipTransform
+split: val

configs/dataset/train_transform/fast_clip.yaml

@@ -0,0 +1,12 @@
+_target_: torchvision.transforms.Compose
+transforms:
+  - _target_: torchvision.transforms.Resize
+    size: 224
+    interpolation: 3
+    antialias: true
+  - _target_: torchvision.transforms.CenterCrop
+    size: 224
+  - _target_: torchvision.transforms.ToTensor
+  - _target_: torchvision.transforms.Normalize
+    mean: [0.48145466, 0.4578275, 0.40821073]
+    std: [0.26862954, 0.26130258, 0.27577711]

configs/dataset/train_transform/fast_resnet.yaml

@@ -0,0 +1,12 @@
+_target_: torchvision.transforms.Compose
+transforms:
+  - _target_: torchvision.transforms.Resize
+    size: 224
+    interpolation: 3
+    antialias: true
+  - _target_: torchvision.transforms.CenterCrop
+    size: 224
+  - _target_: torchvision.transforms.ToTensor
+  - _target_: torchvision.transforms.Normalize
+    mean: [0.485 ,0.456 ,0.406]
+    std: [0.229, 0.224, 0.225]

configs/dataset/train_transform/none.yaml

@@ -0,0 +1,7 @@
+_target_: torchvision.transforms.Compose
+transforms:
+  - _target_: torchvision.transforms.Resize
+    size: 224
+    interpolation: 3
+    antialias: true
+  - _target_: torchvision.transforms.ToTensor

configs/exp/DinoV2.yaml

@@ -0,0 +1,18 @@
+# @package _global_
+
+defaults:
+  - override /model: regression
+  - override /model/network/backbone: dinov2_vitl14
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 30
+
+dataset:
+  global_batch_size: 2048

configs/exp/ResNet.yaml

@@ -0,0 +1,21 @@
+# @package _global_
+
+defaults:
+  - override /model: regression
+  - override /dataset/test_transform: fast_resnet
+  - override /dataset/train_transform: fast_resnet 
+  - override /model.network.mid: mlp_resnet
+  - override /model/network/backbone: ResNet50
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 30
+
+dataset:
+  global_batch_size: 2048

configs/exp/base_model.yaml

@@ -0,0 +1,19 @@
+# @package _global_
+
+defaults:
+  - override /model: regression
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+model:
+  name: base_model
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 30
+
+dataset:
+  global_batch_size: 2048

configs/exp/best_model.yaml

@@ -0,0 +1,25 @@
+# @package _global_
+
+defaults:
+  - override /dataset: osv5m_contrastive_best
+  - override /model: hybrid
+  - override /model/network: best_backbone
+  - override /model/network/backbone: clip_L_14_DataComp
+  - override /model/network/mid: mlp_hybrid
+  - override /model/loss: best_model
+  - _self_
+
+class_name: 'quadtree_10_1000'
+is_baseline: false
+max_epochs: 30
+
+model:
+  name: best_model
+  optimizer:
+    optim:
+      lr: 2e-4
+      weight_decay: 0.0001
+    backbone_lr: 2e-5
+
+dataset:
+  global_batch_size: 2048

configs/exp/classification_area.yaml

@@ -0,0 +1,19 @@
+# @package _global_
+
+defaults:
+  - override /model: classification
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+class_name: 'area'
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 15
+
+dataset:
+  global_batch_size: 2048

configs/exp/classification_cell.yaml

@@ -0,0 +1,19 @@
+# @package _global_
+
+defaults:
+  - override /model: classification
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+class_name: quadtree_10_1000
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 15
+
+dataset:
+  global_batch_size: 2048

configs/exp/classification_cell_hier.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+defaults:
+  - override /model: classification
+  - override /model/network/backbone: openclip_B_32
+  - override /model/loss: cls_hier_quad
+  - _self_
+
+class_name: quadtree_10_1000
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 15
+
+dataset:
+  global_batch_size: 2048

configs/exp/classification_city.yaml

@@ -0,0 +1,19 @@
+# @package _global_
+
+defaults:
+  - override /model: classification
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+class_name: 'city'
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 15
+
+dataset:
+  global_batch_size: 2048

configs/exp/classification_city_hier.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+defaults:
+  - override /model: classification
+  - override /model/network/backbone: openclip_B_32
+  - override /model/loss: cls_hier
+  - _self_
+
+class_name: 'city'
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 15
+
+dataset:
+  global_batch_size: 2048

configs/exp/classification_country.yaml

@@ -0,0 +1,19 @@
+# @package _global_
+
+defaults:
+  - override /model: classification
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+class_name: 'country'
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 15
+
+dataset:
+  global_batch_size: 2048

configs/exp/classification_region copy.yaml

@@ -0,0 +1,19 @@
+# @package _global_
+
+defaults:
+  - override /model: classification
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+class_name: 'region'
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 15
+
+dataset:
+  global_batch_size: 2048

configs/exp/classification_region.yaml

@@ -0,0 +1,19 @@
+# @package _global_
+
+defaults:
+  - override /model: classification
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+class_name: 'region'
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 15
+
+dataset:
+  global_batch_size: 2048

configs/exp/clip_L_14_DataComp.yaml

@@ -0,0 +1,18 @@
+# @package _global_
+
+defaults:
+  - override /model: regression
+  - override /model/network/backbone: clip_L_14_DataComp
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 30
+
+dataset:
+  global_batch_size: 2048

configs/exp/clip_L_14_Laion.yaml

@@ -0,0 +1,18 @@
+# @package _global_
+
+defaults:
+  - override /model: regression
+  - override /model/network/backbone: openclip_L_14
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 30
+
+dataset:
+  global_batch_size: 2048

configs/exp/clip_L_14_OpenAI.yaml

@@ -0,0 +1,18 @@
+# @package _global_
+
+defaults:
+  - override /model: regression
+  - override /model/network/backbone: clip_L_14
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 30
+
+dataset:
+  global_batch_size: 2048

configs/exp/clip_bigG_14_Laion.yaml

@@ -0,0 +1,18 @@
+# @package _global_
+
+defaults:
+  - override /model: regression
+  - override /model/network/backbone: openclip_bigG_14
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+max_epochs: 30
+
+dataset:
+  global_batch_size: 2048

configs/exp/contrastive_area.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+defaults:
+  - override /dataset: osv5m_contrastive
+  - override /model: regression
+  - override /model/network: contrastive_unfrozen_backbone
+  - override /model/network/backbone: openclip_B_32
+  - override /model/loss: contrastive
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 2e-4
+      weight_decay: 0.0001
+    backbone_lr: 2e-5
+
+class_name: area
+is_baseline: false
+max_epochs: 30

configs/exp/contrastive_cell.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+defaults:
+  - override /dataset: osv5m_contrastive
+  - override /model: regression
+  - override /model/network: contrastive_unfrozen_backbone
+  - override /model/network/backbone: openclip_B_32
+  - override /model/loss: contrastive
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 2e-4
+      weight_decay: 0.0001
+    backbone_lr: 2e-5
+
+class_name: quadtree_10_1000
+is_baseline: false
+max_epochs: 30

configs/exp/contrastive_city.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+defaults:
+  - override /dataset: osv5m_contrastive
+  - override /model: regression
+  - override /model/network: contrastive_unfrozen_backbone
+  - override /model/network/backbone: openclip_B_32
+  - override /model/loss: contrastive
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 2e-4
+      weight_decay: 0.0001
+    backbone_lr: 2e-5
+
+class_name: city
+is_baseline: false
+max_epochs: 30

configs/exp/contrastive_country.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+defaults:
+  - override /dataset: osv5m_contrastive
+  - override /model: regression
+  - override /model/network: contrastive_unfrozen_backbone
+  - override /model/network/backbone: openclip_B_32
+  - override /model/loss: contrastive
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 2e-4
+      weight_decay: 0.0001
+    backbone_lr: 2e-5
+
+class_name: country
+is_baseline: false
+max_epochs: 30

configs/exp/contrastive_region.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+defaults:
+  - override /dataset: osv5m_contrastive
+  - override /model: regression
+  - override /model/network: contrastive_unfrozen_backbone
+  - override /model/network/backbone: openclip_B_32
+  - override /model/loss: contrastive
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 2e-4
+      weight_decay: 0.0001
+    backbone_lr: 2e-5
+
+class_name: region
+is_baseline: false
+max_epochs: 30

configs/exp/contrastive_text.yaml

@@ -0,0 +1,22 @@
+# @package _global_
+
+defaults:
+  - override /dataset: osv5m_text_contrastive
+  - override /model: text_tuning
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+model:
+  network:
+    backbone:
+      instance:
+        _target_: models.networks.backbones.CLIPText
+  optimizer:
+    optim:
+      lr: 0.0002
+      weight_decay: 0.0001
+
+is_baseline: false
+class_name: city
+text_tuning: True
+max_epochs: 30

configs/exp/eval_best_model.yaml

@@ -0,0 +1,29 @@
+# @package _global_
+
+defaults:
+  - override /dataset: osv5m_contrastive_best
+  - override /model: hybrid
+  - override /model/network: best_backbone
+  - override /model/network/backbone: clip_L_14_DataComp
+  - override /model/network/mid: mlp_hybrid
+  - _self_
+
+class_name: 'quadtree_10_1000'
+is_baseline: false
+max_epochs: 30
+mode: 'eval'
+
+model:
+  name: best_model
+  optimizer:
+    optim:
+      lr: 2e-4
+      weight_decay: 0.0001
+    backbone_lr: 2e-5
+  network:
+    head:
+      instance:
+        quadtree_path: ${root_dir}/quadtree_10_1000.csv
+
+dataset:
+  global_batch_size: 2048

configs/exp/fine_tuning.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+defaults:
+  - override /model: regression
+  - override /model/network: unfrozen_backbone
+  - override /model/network/backbone: openclip_B_32
+  - _self_
+
+model:
+  optimizer:
+    optim:
+      lr: 2e-4
+      weight_decay: 0.0001
+    backbone_lr: 2e-5
+
+is_baseline: false
+max_epochs: 30
+
+dataset:
+  global_batch_size: 2048