Spaces:
Running
Running
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| import tempfile | |
| import plotly.graph_objects as go | |
| import plotly.express as px | |
| from urllib.parse import urlencode | |
| from plotly.subplots import make_subplots | |
| import requests | |
| from datetime import datetime, timedelta | |
| import warnings | |
| import json | |
| warnings.filterwarnings('ignore') | |
| class EnhancedOceanClimateAgent: | |
| def __init__(self): | |
| self.anomaly_threshold = 2.0 | |
| self.critical_temp_change = 1.5 | |
| # Fixed NOAA API base URL | |
| self.noaa_base_url = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter" | |
| self.noaa_stations_url = "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations.json" | |
| # Popular NOAA stations for different regions | |
| self.default_stations = { | |
| "San Francisco, CA": "9414290", | |
| "New York, NY": "8518750", | |
| "Miami, FL": "8723214", | |
| "Seattle, WA": "9447130", | |
| "Boston, MA": "8443970", | |
| "Los Angeles, CA": "9410660", | |
| "Galveston, TX": "8771450", | |
| "Charleston, SC": "8665530" | |
| } | |
| def get_noaa_data(self, station_id, product, begin_date, end_date, units="metric"): | |
| """Fetch NOAA data for a given product and date range""" | |
| # Format dates for NOAA API | |
| begin_str = begin_date.strftime("%Y%m%d %H:%M") | |
| end_str = end_date.strftime("%Y%m%d %H:%M") | |
| params = { | |
| 'station': station_id, | |
| 'product': product, | |
| 'begin_date': begin_str, | |
| 'end_date': end_str, | |
| 'datum': 'MLLW', # Mean Lower Low Water | |
| 'application': 'OceanClimateAgent', | |
| 'time_zone': 'gmt', | |
| 'units': units, | |
| 'format': 'json' | |
| } | |
| try: | |
| print(f"Fetching {product} data for station {station_id}") | |
| print(f"Date range: {begin_str} to {end_str}") | |
| response = requests.get(self.noaa_base_url, params=params, timeout=30) | |
| if response.status_code != 200: | |
| print(f"HTTP Error {response.status_code}: {response.text}") | |
| return None | |
| data = response.json() | |
| if 'data' in data and data['data']: | |
| print(f"Successfully fetched {len(data['data'])} records for {product}") | |
| return pd.DataFrame(data['data']) | |
| elif 'error' in data: | |
| print(f"NOAA API error for {product}: {data['error']['message']}") | |
| return None | |
| else: | |
| print(f"No data returned for {product}") | |
| return None | |
| except requests.exceptions.Timeout: | |
| print(f"Timeout fetching {product} data") | |
| return None | |
| except requests.exceptions.RequestException as e: | |
| print(f"Request failed for {product}: {str(e)}") | |
| return None | |
| except json.JSONDecodeError as e: | |
| print(f"JSON decode error for {product}: {str(e)}") | |
| return None | |
| except Exception as e: | |
| print(f"Unexpected error fetching {product}: {str(e)}") | |
| return None | |
| def get_comprehensive_station_data(self, station_name, days_back=30): | |
| """Get comprehensive data from a NOAA station""" | |
| station_id = self.default_stations.get(station_name) | |
| if not station_id: | |
| return None, "Station not found" | |
| # Ensure end_date is not in the future and allow for some buffer | |
| end_date = datetime.utcnow() - timedelta(hours=2) # 2 hour buffer | |
| start_date = end_date - timedelta(days=days_back) | |
| print(f"Fetching data for {station_name} (ID: {station_id})") | |
| print(f"Date range: {start_date} to {end_date}") | |
| # Priority order - start with most reliable products | |
| products_to_fetch = [ | |
| ('water_level', 'water_level'), | |
| ('water_temperature', 'water_temperature'), | |
| ('air_temperature', 'air_temperature'), | |
| ('wind', 'wind'), | |
| ('air_pressure', 'air_pressure') | |
| ] | |
| all_data = {} | |
| success_count = 0 | |
| for product_name, product_code in products_to_fetch: | |
| print(f"Attempting to fetch {product_name}...") | |
| data = self.get_noaa_data(station_id, product_code, start_date, end_date) | |
| if data is not None and not data.empty: | |
| all_data[product_name] = data | |
| success_count += 1 | |
| print(f"{product_name}: {len(data)} records") | |
| else: | |
| print(f"{product_name}: No data available") | |
| if success_count == 0: | |
| return None, f"No data available for station {station_name} in the specified time period. This could be due to: station maintenance, data processing delays, or the station may not support the requested data types." | |
| print(f"Successfully retrieved {success_count}/{len(products_to_fetch)} data types") | |
| return all_data, f"Successfully retrieved {success_count}/{len(products_to_fetch)} data types" | |
| def process_noaa_data(self, raw_data): | |
| """Process and combine NOAA data for analysis""" | |
| if not raw_data: | |
| return None | |
| base_df = None | |
| # Start with water level data if available (most common) | |
| if 'water_level' in raw_data: | |
| df = raw_data['water_level'].copy() | |
| df['datetime'] = pd.to_datetime(df['t']) | |
| df['water_level'] = pd.to_numeric(df['v'], errors='coerce') | |
| base_df = df[['datetime', 'water_level']].copy() | |
| print(f"Base dataset: water_level with {len(base_df)} records") | |
| # If no water level, try other datasets | |
| if base_df is None: | |
| for product_name in ['water_temperature', 'air_temperature', 'wind', 'air_pressure']: | |
| if product_name in raw_data: | |
| df = raw_data[product_name].copy() | |
| df['datetime'] = pd.to_datetime(df['t']) | |
| if product_name == 'wind': | |
| df['wind_speed'] = pd.to_numeric(df['s'], errors='coerce') | |
| base_df = df[['datetime', 'wind_speed']].copy() | |
| else: | |
| column_name = product_name.replace('_temperature', '_temp') | |
| df[column_name] = pd.to_numeric(df['v'], errors='coerce') | |
| base_df = df[['datetime', column_name]].copy() | |
| print(f"Base dataset: {product_name} with {len(base_df)} records") | |
| break | |
| if base_df is None: | |
| return None | |
| # Add other parameters when available | |
| if 'water_temperature' in raw_data and 'water_temp' not in base_df.columns: | |
| temp_df = raw_data['water_temperature'].copy() | |
| temp_df['datetime'] = pd.to_datetime(temp_df['t']) | |
| temp_df['water_temp'] = pd.to_numeric(temp_df['v'], errors='coerce') | |
| base_df = base_df.merge(temp_df[['datetime', 'water_temp']], on='datetime', how='outer') | |
| if 'air_temperature' in raw_data and 'air_temp' not in base_df.columns: | |
| air_temp_df = raw_data['air_temperature'].copy() | |
| air_temp_df['datetime'] = pd.to_datetime(air_temp_df['t']) | |
| air_temp_df['air_temp'] = pd.to_numeric(air_temp_df['v'], errors='coerce') | |
| base_df = base_df.merge(air_temp_df[['datetime', 'air_temp']], on='datetime', how='outer') | |
| if 'wind' in raw_data and 'wind_speed' not in base_df.columns: | |
| wind_df = raw_data['wind'].copy() | |
| wind_df['datetime'] = pd.to_datetime(wind_df['t']) | |
| wind_df['wind_speed'] = pd.to_numeric(wind_df['s'], errors='coerce') | |
| wind_df['wind_direction'] = pd.to_numeric(wind_df['d'], errors='coerce') | |
| base_df = base_df.merge(wind_df[['datetime', 'wind_speed', 'wind_direction']], on='datetime', how='outer') | |
| if 'air_pressure' in raw_data and 'air_pressure' not in base_df.columns: | |
| pressure_df = raw_data['air_pressure'].copy() | |
| pressure_df['datetime'] = pd.to_datetime(pressure_df['t']) | |
| pressure_df['air_pressure'] = pd.to_numeric(pressure_df['v'], errors='coerce') | |
| base_df = base_df.merge(pressure_df[['datetime', 'air_pressure']], on='datetime', how='outer') | |
| # Sort by datetime and remove duplicates | |
| base_df = base_df.sort_values('datetime').drop_duplicates(subset=['datetime']) | |
| print(f"Final processed dataset: {len(base_df)} records with {len(base_df.columns)-1} parameters") | |
| return base_df | |
| def detect_anomalies(self, data, column, window=24): # 24 hours for hourly data | |
| """Detect anomalies using rolling statistics""" | |
| if column not in data.columns or data[column].isna().all(): | |
| return pd.Series([False] * len(data)), pd.Series([0] * len(data)) | |
| rolling_mean = data[column].rolling(window=window, center=True, min_periods=1).mean() | |
| rolling_std = data[column].rolling(window=window, center=True, min_periods=1).std() | |
| # Avoid division by zero | |
| rolling_std = rolling_std.fillna(1) | |
| rolling_std = rolling_std.replace(0, 1) | |
| z_scores = np.abs((data[column] - rolling_mean) / rolling_std) | |
| anomalies = z_scores > self.anomaly_threshold | |
| return anomalies, z_scores | |
| def calculate_trends(self, data, column, hours=168): # 7 days | |
| """Calculate trend over specified period""" | |
| if column not in data.columns or data[column].isna().all(): | |
| return 0 | |
| recent_data = data.tail(hours) | |
| if len(recent_data) < 2: | |
| return 0 | |
| x = np.arange(len(recent_data)) | |
| y = recent_data[column].dropna() | |
| if len(y) < 2: | |
| return 0 | |
| x = x[:len(y)] | |
| slope = np.polyfit(x, y, 1)[0] if len(x) > 1 else 0 | |
| return slope | |
| def generate_climate_analysis(self, data, station_name): | |
| """Generate comprehensive climate analysis""" | |
| if data is None or data.empty: | |
| return {}, [] | |
| analysis = {} | |
| alerts = [] | |
| # Water level analysis | |
| if 'water_level' in data.columns: | |
| wl_trend = self.calculate_trends(data, 'water_level') | |
| analysis['water_level_trend'] = wl_trend * 24 # per day | |
| if abs(wl_trend * 24) > 5: # >5cm per day change | |
| alerts.append(f"Significant water level change: {wl_trend*24:.1f}cm/day at {station_name}") | |
| # Temperature analysis | |
| for temp_col in ['water_temp', 'air_temp']: | |
| if temp_col in data.columns: | |
| temp_trend = self.calculate_trends(data, temp_col) | |
| analysis[f'{temp_col}_trend'] = temp_trend * 24 # per day | |
| if temp_trend * 24 > 0.5: # >0.5°C per day | |
| alerts.append(f"Rapid {temp_col.replace('_', ' ')} rise: {temp_trend*24:.2f}°C/day at {station_name}") | |
| # Anomaly detection | |
| for col in ['water_level', 'water_temp', 'air_temp', 'wind_speed']: | |
| if col in data.columns: | |
| anomalies, z_scores = self.detect_anomalies(data, col) | |
| anomaly_pct = (anomalies.sum() / len(data)) * 100 | |
| analysis[f'{col}_anomaly_frequency'] = anomaly_pct | |
| if anomaly_pct > 10: | |
| alerts.append(f"High {col.replace('_', ' ')} anomaly frequency: {anomaly_pct:.1f}% at {station_name}") | |
| if not alerts: | |
| alerts.append(f"No significant anomalies detected at {station_name}") | |
| return analysis, alerts | |
| # Initialize the enhanced agent | |
| agent = EnhancedOceanClimateAgent() | |
| def analyze_real_ocean_data(station_name, days_back, anomaly_sensitivity, use_real_data): | |
| """Main analysis function with real NOAA data""" | |
| agent.anomaly_threshold = anomaly_sensitivity | |
| if use_real_data: | |
| print(f"Starting real data analysis for {station_name}") | |
| # Fetch real NOAA data | |
| raw_data, status_msg = agent.get_comprehensive_station_data(station_name, days_back) | |
| if raw_data is None: | |
| error_msg = f"Error fetching real data: {status_msg}" | |
| print(error_msg) | |
| return None, None, None, error_msg, "No alerts - data unavailable", None | |
| # Process the data | |
| data = agent.process_noaa_data(raw_data) | |
| if data is None or data.empty: | |
| error_msg = "No processable data available after fetching from NOAA" | |
| print(error_msg) | |
| return None, None, None, error_msg, "No alerts - data unavailable", None | |
| data_source = f"Real NOAA data from {station_name} ({status_msg})" | |
| print(f"{data_source}") | |
| else: | |
| print("🔧 Using synthetic demonstration data") | |
| # Use synthetic data for demonstration | |
| data = generate_synthetic_data(days_back) | |
| data_source = f"🔧 Synthetic demonstration data ({days_back} days)" | |
| # Generate analysis and alerts | |
| analysis, alerts = agent.generate_climate_analysis(data, station_name) | |
| # Create visualizations | |
| fig1 = create_main_dashboard(data, agent) | |
| fig2 = create_anomaly_plots(data, agent) | |
| fig3 = create_correlation_plot(data) | |
| # Format analysis text | |
| analysis_text = format_analysis_results(analysis, data_source) | |
| alerts_text = "\n".join([f"- {alert}" for alert in alerts]) | |
| # Create CSV for download | |
| csv_file_path = save_csv_temp(data) | |
| print("Analysis completed successfully") | |
| return fig1, fig2, fig3, analysis_text, alerts_text, csv_file_path | |
| def generate_synthetic_data(days): | |
| """Generate synthetic data for demonstration""" | |
| dates = pd.date_range(start=datetime.now() - timedelta(days=days), periods=days*24, freq='H') | |
| # Synthetic water level with tidal patterns | |
| tidal_pattern = 2 * np.sin(2 * np.pi * np.arange(len(dates)) / 12.42) # M2 tide | |
| water_level = 100 + tidal_pattern + np.random.normal(0, 0.3, len(dates)) | |
| # Water temperature with daily cycle | |
| daily_temp_cycle = 2 * np.sin(2 * np.pi * np.arange(len(dates)) / 24) | |
| water_temp = 15 + daily_temp_cycle + np.random.normal(0, 0.5, len(dates)) | |
| # Wind patterns | |
| wind_speed = 5 + 3 * np.sin(2 * np.pi * np.arange(len(dates)) / (24*3)) + np.random.normal(0, 1, len(dates)) | |
| wind_direction = 180 + 45 * np.sin(2 * np.pi * np.arange(len(dates)) / (24*2)) + np.random.normal(0, 20, len(dates)) | |
| return pd.DataFrame({ | |
| 'datetime': dates, | |
| 'water_level': water_level, | |
| 'water_temp': water_temp, | |
| 'wind_speed': np.maximum(0, wind_speed), | |
| 'wind_direction': wind_direction % 360, | |
| 'air_pressure': 1013 + np.random.normal(0, 10, len(dates)) | |
| }) | |
| def create_main_dashboard(data, agent): | |
| """Create main dashboard visualization""" | |
| available_plots = [] | |
| plot_data = [] | |
| # Check what data is available | |
| if 'water_level' in data.columns and not data['water_level'].isna().all(): | |
| available_plots.append(('Water Level', 'water_level', 'blue')) | |
| if 'water_temp' in data.columns and not data['water_temp'].isna().all(): | |
| available_plots.append(('Water Temperature', 'water_temp', 'red')) | |
| if 'air_temp' in data.columns and not data['air_temp'].isna().all(): | |
| available_plots.append(('Air Temperature', 'air_temp', 'orange')) | |
| if 'wind_speed' in data.columns and not data['wind_speed'].isna().all(): | |
| available_plots.append(('Wind Speed', 'wind_speed', 'green')) | |
| if 'air_pressure' in data.columns and not data['air_pressure'].isna().all(): | |
| available_plots.append(('Air Pressure', 'air_pressure', 'purple')) | |
| if not available_plots: | |
| fig = go.Figure() | |
| fig.add_annotation(text="No data available for visualization", | |
| xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False) | |
| return fig | |
| # Create subplots based on available data | |
| n_plots = len(available_plots) | |
| rows = (n_plots + 1) // 2 # Ceiling division | |
| cols = 2 if n_plots > 1 else 1 | |
| fig = make_subplots( | |
| rows=rows, cols=cols, | |
| subplot_titles=[plot[0] for plot in available_plots], | |
| vertical_spacing=0.1 | |
| ) | |
| for i, (title, column, color) in enumerate(available_plots): | |
| row = (i // 2) + 1 | |
| col = (i % 2) + 1 | |
| # Add main data line | |
| fig.add_trace( | |
| go.Scatter(x=data['datetime'], y=data[column], | |
| name=title, line=dict(color=color)), | |
| row=row, col=col | |
| ) | |
| # Add anomalies if applicable | |
| anomalies, _ = agent.detect_anomalies(data, column) | |
| if anomalies.any(): | |
| anomaly_data = data[anomalies] | |
| fig.add_trace( | |
| go.Scatter(x=anomaly_data['datetime'], y=anomaly_data[column], | |
| mode='markers', name=f'{title} Anomalies', | |
| marker=dict(color='red', size=6)), | |
| row=row, col=col | |
| ) | |
| fig.update_layout(height=300*rows, showlegend=False, title_text="Ocean and Atmospheric Data Dashboard") | |
| return fig | |
| def create_anomaly_plots(data, agent): | |
| """Create anomaly detection plots""" | |
| available_cols = [col for col in ['water_level', 'water_temp', 'air_temp', 'wind_speed'] | |
| if col in data.columns and not data[col].isna().all()] | |
| if len(available_cols) == 0: | |
| fig = go.Figure() | |
| fig.add_annotation(text="No data available for anomaly detection", | |
| xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False) | |
| return fig | |
| n_plots = min(len(available_cols), 2) # Maximum 2 plots | |
| fig = make_subplots( | |
| rows=1, cols=n_plots, | |
| subplot_titles=[f'{col.replace("_", " ").title()} Anomalies' for col in available_cols[:n_plots]] | |
| ) | |
| colors = ['blue', 'red', 'green', 'purple'] | |
| for i, col in enumerate(available_cols[:n_plots]): | |
| _, z_scores = agent.detect_anomalies(data, col) | |
| fig.add_trace( | |
| go.Scatter(x=data['datetime'], y=z_scores, | |
| mode='lines', name=f'{col} Z-Score', | |
| line=dict(color=colors[i % len(colors)])), | |
| row=1, col=i+1 | |
| ) | |
| fig.add_hline(y=agent.anomaly_threshold, line_dash="dash", line_color="red", row=1, col=i+1) | |
| fig.update_layout(height=400, showlegend=False, title_text="Anomaly Detection Analysis") | |
| return fig | |
| def create_correlation_plot(data): | |
| """Create correlation heatmap""" | |
| numeric_cols = [col for col in ['water_level', 'water_temp', 'air_temp', 'wind_speed', 'air_pressure'] | |
| if col in data.columns and not data[col].isna().all()] | |
| if len(numeric_cols) < 2: | |
| # Return empty plot if insufficient data | |
| fig = go.Figure() | |
| fig.add_annotation(text="Insufficient data for correlation analysis", | |
| xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False) | |
| return fig | |
| corr_matrix = data[numeric_cols].corr() | |
| fig = px.imshow(corr_matrix, | |
| labels=dict(color="Correlation"), | |
| color_continuous_scale='RdBu_r', | |
| aspect="auto", | |
| title="Parameter Correlations") | |
| return fig | |
| def format_analysis_results(analysis, data_source): | |
| """Format analysis results for display""" | |
| result = f"### {data_source}\n\n**Key Trends:**\n" | |
| if not analysis: | |
| result += "- No analysis data available\n" | |
| return result | |
| for key, value in analysis.items(): | |
| if 'trend' in key: | |
| param = key.replace('_trend', '').replace('_', ' ').title() | |
| unit = 'cm/day' if 'water_level' in key else '°C/day' if 'temp' in key else 'units/day' | |
| result += f"- {param}: {value:.3f} {unit}\n" | |
| elif 'anomaly_frequency' in key: | |
| param = key.replace('_anomaly_frequency', '').replace('_', ' ').title() | |
| result += f"- {param} anomalies: {value:.1f}%\n" | |
| return result | |
| def save_csv_temp(data): | |
| """Save data to temporary CSV file""" | |
| tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode='w', newline='', encoding='utf-8') | |
| data.to_csv(tmp.name, index=False) | |
| tmp.close() | |
| return tmp.name | |
| # Create Gradio interface | |
| with gr.Blocks(title="Enhanced Ocean Climate Monitoring AI Agent", theme=gr.themes.Ocean()) as demo: | |
| gr.Markdown(""" | |
| # Enhanced Ocean Climate Monitoring AI Agent | |
| ### Real-time Analysis with NOAA Data Integration | |
| This enhanced AI agent can fetch real ocean data from NOAA stations or use synthetic data for demonstration. | |
| Monitor water levels, temperature, currents, and detect climate anomalies at major coastal locations. | |
| **Note:** NOAA stations may not have all data types available. The system will use whatever data is accessible. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### Configuration") | |
| station_name = gr.Dropdown( | |
| choices=list(agent.default_stations.keys()), | |
| value="San Francisco, CA", | |
| label="NOAA Station Location" | |
| ) | |
| days_back = gr.Slider( | |
| minimum=1, | |
| maximum=30, | |
| value=7, | |
| step=1, | |
| label="Days of Historical Data", | |
| info="Shorter periods are more reliable" | |
| ) | |
| anomaly_sensitivity = gr.Slider( | |
| minimum=1.0, | |
| maximum=3.0, | |
| value=2.0, | |
| step=0.1, | |
| label="Anomaly Detection Sensitivity" | |
| ) | |
| use_real_data = gr.Checkbox( | |
| label="Use Real NOAA Data", | |
| value=True, | |
| info="Uncheck to use synthetic data" | |
| ) | |
| analyze_btn = gr.Button("Analyze Ocean Data", variant="primary") | |
| with gr.Column(scale=2): | |
| gr.Markdown("### Climate Alerts") | |
| alerts_output = gr.Markdown() | |
| with gr.Row(): | |
| analysis_output = gr.Markdown() | |
| with gr.Tab("Main Dashboard"): | |
| dashboard_plot = gr.Plot() | |
| with gr.Tab("Anomaly Detection"): | |
| anomaly_plot = gr.Plot() | |
| with gr.Tab("Correlations"): | |
| correlation_plot = gr.Plot() | |
| with gr.Tab("Data Export"): | |
| gr.Markdown("### Download Analyzed Data") | |
| csv_output = gr.File(label="Download CSV Data") | |
| gr.Markdown("*Note: Real NOAA data usage is subject to their terms of service*") | |
| # Set up the analysis function | |
| analyze_btn.click( | |
| fn=analyze_real_ocean_data, | |
| inputs=[station_name, days_back, anomaly_sensitivity, use_real_data], | |
| outputs=[dashboard_plot, anomaly_plot, correlation_plot, analysis_output, alerts_output, csv_output] | |
| ) | |
| # Auto-run on startup with synthetic data | |
| demo.load( | |
| fn=analyze_real_ocean_data, | |
| inputs=[ | |
| gr.Text(value="San Francisco, CA", visible=False), | |
| gr.Number(value=7, visible=False), | |
| gr.Number(value=2.0, visible=False), | |
| gr.Checkbox(value=False, visible=False) # Start with synthetic data | |
| ], | |
| outputs=[dashboard_plot, anomaly_plot, correlation_plot, analysis_output, alerts_output, csv_output] | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch() |