| 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
|
| 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()
|
|
|
