Create app.py

app.py

@@ -0,0 +1,170 @@
+from geopy.geocoders import OpenCageGeocode
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from datasets import load_dataset
+import folium
+from streamlit_folium import st_folium
+
+# Initialize geolocator with OpenCage API
+API_KEY = "YOUR_OPENCAGE_API_KEY"  # Replace with your OpenCage API key
+geolocator = OpenCageGeocode(API_KEY)
+
+# Hugging Face Datasets
+@st.cache_data
+def load_data():
+    network_insights = load_dataset("infinite-dataset-hub/5GNetworkOptimization", split="train")
+    return network_insights.to_pandas()
+
+# Load Datasets
+network_insights = load_data()
+
+# Title
+st.title("Smart Network Infrastructure Planner")
+st.sidebar.header("Input Parameters")
+
+# User Inputs from Sidebar
+budget = st.sidebar.number_input("Total Budget (in $1000s):", min_value=10, max_value=1000, step=10)
+priority_area = st.sidebar.selectbox("Priority Area:", ["Rural", "Urban", "Suburban"])
+signal_threshold = st.sidebar.slider("Signal Strength Threshold (dBm):", min_value=-120, max_value=-30, value=-80)
+terrain_weight = st.sidebar.slider("Terrain Difficulty Weight:", min_value=0.0, max_value=1.0, value=0.5)
+cost_weight = st.sidebar.slider("Cost Weight:", min_value=0.0, max_value=1.0, value=0.5)
+include_human_readable = st.sidebar.checkbox("Include Human-Readable Info", value=True)
+
+# Display Dataset Options
+data_to_view = st.sidebar.selectbox("Select Dataset to View:", ["Network Insights", "Filtered Terrain Data"])
+
+# Terrain and Connectivity Analysis Section
+st.header("Terrain and Connectivity Analysis")
+
+# Simulate Terrain Data
+def generate_terrain_data():
+    np.random.seed(42)
+    data = {
+        "Region": [f"Region-{i}" for i in range(1, 11)],
+        "Latitude": np.random.uniform(30.0, 50.0, size=10),
+        "Longitude": np.random.uniform(-120.0, -70.0, size=10),
+        "Terrain Difficulty (0-10)": np.random.randint(1, 10, size=10),
+        "Signal Strength (dBm)": np.random.randint(-120, -30, size=10),
+        "Cost ($1000s)": np.random.randint(50, 200, size=10),
+        "Priority Area": np.random.choice(["Rural", "Urban", "Suburban"], size=10),
+        "Description": [
+            "Flat area with minimal obstacles",
+            "Hilly terrain, moderate construction difficulty",
+            "Dense urban area with high costs",
+            "Suburban area, balanced terrain",
+            "Mountainous region, challenging setup",
+            "Remote rural area, sparse population",
+            "Coastal area, potential for high signal interference",
+            "Industrial zone, requires robust infrastructure",
+            "Dense forest region, significant signal attenuation",
+            "Open plains, optimal for cost-effective deployment"
+        ]
+    }
+    return pd.DataFrame(data)
+
+terrain_data = generate_terrain_data()
+
+# Reverse Geocoding Function
+def get_location_name(lat, lon):
+    try:
+        location = geolocator.reverse((lat, lon), language="en")
+        if location and "formatted" in location:
+            return location["formatted"]
+        return "Location not found"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Add Location Name to Filtered Data
+if include_human_readable:
+    filtered_data = terrain_data[
+        (terrain_data["Signal Strength (dBm)"] >= signal_threshold) & 
+        (terrain_data["Cost ($1000s)"] <= budget) & 
+        (terrain_data["Priority Area"] == priority_area)
+    ]
+    filtered_data["Location Name"] = filtered_data.apply(
+        lambda row: get_location_name(row["Latitude"], row["Longitude"]), axis=1
+    )
+else:
+    filtered_data = terrain_data[
+        (terrain_data["Signal Strength (dBm)"] >= signal_threshold) & 
+        (terrain_data["Cost ($1000s)"] <= budget) & 
+        (terrain_data["Priority Area"] == priority_area)
+    ]
+
+# Add Composite Score for Ranking
+filtered_data["Composite Score"] = (
+    (1 - terrain_weight) * filtered_data["Signal Strength (dBm)"] + 
+    (terrain_weight) * (10 - filtered_data["Terrain Difficulty (0-10)"]) - 
+    (cost_weight) * filtered_data["Cost ($1000s)"]
+)
+
+# Display Selected Dataset
+if data_to_view == "Network Insights":
+    st.subheader("Network Insights Dataset")
+    st.dataframe(network_insights)
+elif data_to_view == "Filtered Terrain Data":
+    st.subheader("Filtered Terrain Data")
+    columns_to_display = [
+        "Region", "Location Name", "Priority Area", "Signal Strength (dBm)",
+        "Cost ($1000s)", "Terrain Difficulty (0-10)", "Description", "Composite Score"
+    ] if include_human_readable else [
+        "Region", "Priority Area", "Signal Strength (dBm)", "Cost ($1000s)", "Terrain Difficulty (0-10)", "Description", "Composite Score"
+    ]
+    st.dataframe(filtered_data[columns_to_display])
+
+# Map Visualization
+st.header("Geographical Map of Regions")
+if not filtered_data.empty:
+    map_center = [filtered_data["Latitude"].mean(), filtered_data["Longitude"].mean()]
+    region_map = folium.Map(location=map_center, zoom_start=6)
+
+    for _, row in filtered_data.iterrows():
+        folium.Marker(
+            location=[row["Latitude"], row["Longitude"]],
+            popup=(f"<b>Region:</b> {row['Region']}<br>"
+                   f"<b>Location:</b> {row.get('Location Name', 'N/A')}<br>"
+                   f"<b>Description:</b> {row['Description']}<br>"
+                   f"<b>Signal Strength:</b> {row['Signal Strength (dBm)']} dBm<br>"
+                   f"<b>Cost:</b> ${row['Cost ($1000s)']}k<br>"
+                   f"<b>Terrain Difficulty:</b> {row['Terrain Difficulty (0-10)']}"),
+            icon=folium.Icon(color="blue", icon="info-sign")
+        ).add_to(region_map)
+
+    st_folium(region_map, width=700, height=500)
+else:
+    st.write("No regions match the selected criteria.")
+
+# Visualization
+fig = px.scatter(
+    filtered_data,
+    x="Cost ($1000s)",
+    y="Signal Strength (dBm)",
+    size="Terrain Difficulty (0-10)",
+    color="Region",
+    title="Signal Strength vs. Cost",
+    labels={
+        "Cost ($1000s)": "Cost in $1000s",
+        "Signal Strength (dBm)": "Signal Strength in dBm",
+    },
+)
+st.plotly_chart(fig)
+
+# Recommendation Engine
+st.header("Deployment Recommendations")
+
+def recommend_deployment(data):
+    if data.empty:
+        return "No viable deployment regions within the specified parameters."
+    best_region = data.loc[data["Composite Score"].idxmax()]
+    return f"Recommended Region: {best_region['Region']} with Composite Score: {best_region['Composite Score']:.2f}, Signal Strength: {best_region['Signal Strength (dBm)']} dBm, Terrain Difficulty: {best_region['Terrain Difficulty (0-10)']}, and Estimated Cost: ${best_region['Cost ($1000s)']}k\nDescription: {best_region['Description']}\nLocation Name: {best_region.get('Location Name', 'N/A')}"
+
+recommendation = recommend_deployment(filtered_data)
+st.subheader(recommendation)
+
+# Footer
+st.sidebar.markdown("---")
+st.sidebar.markdown(
+    "**Developed for Hackathon using Hugging Face Infinite Dataset Hub**\n\n[Visit Hugging Face](https://huggingface.co)"
+)