Create app.py

app.py

@@ -0,0 +1,170 @@
+import gradio as gr
+import requests
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from fastai.vision.all import *
+from fastai.vision.all import PILImage
+import os
+
+# Load the trained model for image-based fog classification
+learn = load_learner('afog_classifier.pkl')
+labels = learn.dls.vocab
+
+# Use environment variables for API keys
+API_KEY = os.environ.get("OPENWEATHER_API_KEY")
+BASE_URL = 'https://api.openweathermap.org/data/2.5/'
+
+# Define the prediction function for image-based fog classification
+def predict_image(img):
+    img = PILImage.create(img)
+    img = img.resize((512, 512))
+    pred, pred_idx, probs = learn.predict(img)
+    return {labels[i]: float(probs[i]) for i in range(len(labels))}
+
+# Function to get weather data
+def get_weather_data(location):
+    current_weather_url = f'{BASE_URL}weather?q={location}&appid={API_KEY}&units=metric'
+    current_response = requests.get(current_weather_url)
+    current_data = current_response.json()
+
+    current_weather = {
+        'temperature': current_data['main']['temp'],
+        'feels_like': current_data['main']['feels_like'],
+        'description': current_data['weather'][0]['description'],
+        'wind_speed': current_data['wind']['speed'],
+        'pressure': current_data['main']['pressure'],
+        'humidity': current_data['main']['humidity'],
+        'visibility': current_data['visibility'] / 1000,
+        'dew_point': current_data['main']['temp'] - ((100 - current_data['main']['humidity']) / 5.0)
+    }
+    return current_weather
+
+# Function to train the fog prediction model
+def train_fog_model():
+    df = pd.read_csv('fog_weather_data.csv')
+    df = pd.get_dummies(df, columns=['Description'], drop_first=True)
+    X = df.drop('Fog', axis=1)
+    y = df['Fog']
+    model = LogisticRegression()
+    model.fit(X, y)
+    return model, X.columns
+
+# Function to predict fog based on weather data
+def predict_fog(model, feature_columns, weather_data):
+    new_data = pd.DataFrame({
+        'Temperature': [weather_data['temperature']],
+        'Feels like': [weather_data['feels_like']],
+        'Wind speed': [weather_data['wind_speed']],
+        'Pressure': [weather_data['pressure']],
+        'Humidity': [weather_data['humidity']],
+        'Dew point': [weather_data['dew_point']],
+        'Visibility': [weather_data['visibility']]
+    })
+
+    for col in feature_columns:
+        if col.startswith('Description_'):
+            new_data[col] = 0
+
+    description_column = f"Description_{weather_data['description'].replace(' ', '_')}"
+    if description_column in feature_columns:
+        new_data[description_column] = 1
+
+    prediction = model.predict(new_data)
+    return "Foggy weather" if prediction[0] == 1 else "Clear weather"
+
+# Function to get 5-day weather forecast
+def get_5day_forecast(location):
+    forecast_url = f'{BASE_URL}forecast?q={location}&appid={API_KEY}&units=metric'
+    forecast_response = requests.get(forecast_url)
+    forecast_data = forecast_response.json()
+
+    forecast_list = []
+    for entry in forecast_data['list']:
+        forecast_list.append({
+            'date': entry['dt_txt'],
+            'temperature': entry['main']['temp'],
+            'humidity': entry['main']['humidity'],
+            'description': entry['weather'][0]['description']
+        })
+    return forecast_list
+
+# Load the fog prediction model
+fog_model, feature_columns = train_fog_model()
+
+# Function to predict current weather and fog
+def predict_current_weather(location):
+    try:
+        current_weather = get_weather_data(location)
+        fog_prediction = predict_fog(fog_model, feature_columns, current_weather)
+
+        result = f"Current weather in {location}:\n"
+        result += f"Temperature: {current_weather['temperature']}°C\n"
+        result += f"Feels like: {current_weather['feels_like']}°C\n"
+        result += f"Description: {current_weather['description']}\n"
+        result += f"Wind speed: {current_weather['wind_speed']} m/s\n"
+        result += f"Pressure: {current_weather['pressure']} hPa\n"
+        result += f"Humidity: {current_weather['humidity']}%\n"
+        result += f"Dew point: {current_weather['dew_point']}°C\n"
+        result += f"Visibility: {current_weather['visibility']} km\n"
+        result += f"\nFog Prediction: {fog_prediction}"
+
+        return result
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Function to determine transmission power based on combined results
+def determine_transmission_power(image_prediction, weather_prediction, humidity):
+    image_class = max(image_prediction, key=image_prediction.get)
+    weather_class = "Foggy weather" if weather_prediction == "Foggy weather" else "Clear weather"
+
+    if humidity > 80:  # High humidity increases the likelihood of fog
+        if image_class == "Dense_Fog" or weather_class == "Foggy weather":
+            return "High"
+        elif image_class == "Moderate_Fog":
+            return "Medium"
+        else:
+            return "Normal"
+    else:
+        if image_class == "Dense_Fog":
+            return "Medium"
+        elif image_class == "Moderate_Fog":
+            return "Normal"
+        else:
+            return "Normal"
+
+# Main function to integrate all functionalities
+def integrated_prediction(image, location):
+    # Predict fog from image
+    image_prediction = predict_image(image)
+
+    # Get current weather data and predict fog
+    current_weather = get_weather_data(location)
+    weather_prediction = predict_fog(fog_model, feature_columns, current_weather)
+
+    # Get 5-day weather forecast
+    forecast = get_5day_forecast(location)
+
+    # Determine transmission power
+    transmission_power = determine_transmission_power(image_prediction, weather_prediction, current_weather['humidity'])
+
+    # Prepare the result
+    result = f"Current Weather and Fog Prediction:\n{predict_current_weather(location)}\n\n"
+    result += f"5-Day Weather Forecast:\n{forecast}\n\n"
+    result += f"Transmission Power: {transmission_power}"
+
+    return result
+
+# Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Integrated Fog Prediction and Transmission Power Decision")
+
+    with gr.Row():
+        image_input = gr.Image(label="Upload Image")
+        location_input = gr.Textbox(label="Enter Location")
+
+    predict_button = gr.Button("Predict and Determine Transmission Power")
+    output = gr.Textbox(label="Prediction and Transmission Power Result")
+
+    predict_button.click(integrated_prediction, inputs=[image_input, location_input], outputs=output)
+
+demo.launch()