new version

api_data.py

@@ -0,0 +1,36 @@
+import requests
+import datetime
+
+def fetch_data(
+        lookback,
+        span = 24,
+        offset = 3, # data from the api is only upto 3 hours before now
+
+        url = "https://visual-crossing-weather.p.rapidapi.com/history",
+        headers = {
+            "X-RapidAPI-Key": "12c5552beamshb548b266489323cp1c7cb2jsnf8b18027cebc",
+            "X-RapidAPI-Host": "visual-crossing-weather.p.rapidapi.com"
+        }
+):
+    # Calculate the start and end date and time for the last 24 hours
+    end_datetime = datetime.datetime.now() - datetime.timedelta(hours=lookback)
+    start_datetime = end_datetime - datetime.timedelta(hours=(span+offset))
+    querystring = {
+            "startDateTime": start_datetime.strftime("%Y-%m-%dT%H:%M:%S"),
+            "aggregateHours": "1",
+            "location": "Kolkata",
+            "endDateTime": end_datetime.strftime("%Y-%m-%dT%H:%M:%S"),
+            "unitGroup": "us",
+            "dayStartTime": "00:00:00",
+            "contentType": "csv",
+            "dayEndTime": "23:59:00",
+            "shortColumnNames": "0"
+        }
+    response = requests.get(url, headers=headers, params=querystring)
+
+
+    if response.status_code == 200:
+        # Parse the CSV response
+        return response
+    else:
+        print("Error:", response.status_code)

app.py

@@ -0,0 +1,83 @@
+from data_processing import process_data, standardizeX
+from sklearn.preprocessing import OneHotEncoder
+from api_data import fetch_data
+from tensorflow import keras
+import pandas as pd
+import gradio as gr
+import numpy as np
+import pickle
+import io
+
+#========================================================================================================================
+#                                          load the models
+#========================================================================================================================
+temp_model = keras.models.load_model('results/temp_model.h5')
+hum_model = keras.models.load_model('results/hum_model.h5')
+overview_model = keras.models.load_model('results/overview_model.h5')
+
+#========================================================================================================================
+#                                          retrieve mean and std and encoder
+#========================================================================================================================
+encoder = pickle.load(open("results/encoder.pkl", "rb"))
+scale = pickle.load(open("results/mean_std.pkl", "rb"))
+mean = scale["mean"]
+std = scale["std"]
+
+temp_mean = mean[0]
+temp_std = std[0]
+
+hum_mean = mean[2]
+hum_std = std[2]
+
+# overview dictionary
+overview = {
+    0:'Clear',
+    1: 'Clear',
+    2: 'Partially cloudy',
+    2: 'Rain',
+    3: 'Overcast',
+}
+
+
+#========================================================================================================================
+#                                          predict function
+#========================================================================================================================
+def forecast(time):
+    time = int(time)
+    if time>9 or time<0:
+        return "please enter valid time", "0 to 9", ""
+    
+    response = fetch_data(9-time)
+    if response is not None:
+        # processing data to better fit the model
+        df = pd.read_csv(io.StringIO(response.content.decode('utf-8')))
+        df = process_data(df)
+        X = np.array(df[-24:]).reshape(-1, 24, 17)
+        X = standardizeX(X, mean, std)
+
+        # predictions
+        temp = temp_model.predict(X)
+        hum = hum_model.predict(X)
+        ovrvw = overview_model.predict(X)
+
+        # reverse scaling
+        temp = (temp[0][0]*temp_std) + temp_mean
+        hum = (hum[0][0]*hum_std) + hum_mean
+        ovrvw = encoder.inverse_transform(ovrvw)
+
+        # output formatting
+        temp = str(round(((temp-32)*5)/9, 2)) + " c"
+        hum = str(round(hum, 2)) + " %"
+        ovrvw = overview[ovrvw[0][0]]
+        return temp, hum, ovrvw
+    
+    else:
+        return "API access denied", "", ""
+
+
+gr.Interface(fn=forecast, 
+             inputs = gr.Textbox(placeholder="Provide value between 0 to 9, 0 means present, 9 means 9 hrs in future "),
+             outputs = [gr.Textbox(label="Temperature"),gr.Textbox(label="Humidity"),gr.Textbox(label="Overview")]
+            ).launch()
+    
+

data_processing.py

@@ -0,0 +1,75 @@
+import numpy as np
+import pandas as pd
+
+
+# function to map weather values to numerical values
+def map_weather_to_numerical(weather, ordinal_values):
+    val = 0
+    for w in weather.split(","):
+        w = w.strip()
+        if w in ordinal_values:
+            val = max(ordinal_values[w], val)
+    
+    return val
+
+def standardizeX(X, mean, std):
+    for i in range(len(mean)):
+        X[:,:,i] = (X[:, :, i]-mean[i])/std[i]
+    return X
+
+def process_data(df):
+    # Drop redundant columns
+    redundant_cols = [col for col in ["Unnamed: 0", "Minimum Temperature", 
+                                      "Maximum Temperature", "Snow Depth", "Heat Index",
+                                      "Precipitation Cover", "Wind Gust", "Wind Chill", 
+                                      "Snow Depth", "Info", "Latitude",
+                                      "Longitude", "Address", "Resolved Address", "Name"] if col in df.columns]
+    df.drop(redundant_cols, axis=1, inplace=True)
+    
+    # Interpolate missing values
+    df = df.interpolate()
+    
+    # Fill missing values in 'Conditions' and 'Weather Type' columns
+    df['Conditions'].fillna("Clear", inplace=True)
+    df['Weather Type'].fillna("", inplace=True)
+    
+    # Rename column and convert to datetime format
+    df.rename(columns={"Relative Humidity": "Humidity"}, inplace=True)
+    df['DATETIME'] = pd.to_datetime(df['Date time'])
+    
+    # Drop 'Date time' column
+    df.drop(["Date time"], axis=1, inplace=True)
+    
+    # proceessing wind direction
+    angle = (df["Wind Direction"]*np.pi)/360
+    df.drop("Wind Direction", axis=1, inplace=True)
+    df["sin(wind)"] = np.sin(angle)
+    df["cos(wind)"] = np.cos(angle)
+    
+    # Map weather values to numerical values
+    rain_values = {'Heavy Rain': 7, 'Snow And Rain Showers': 6, 'Rain Showers': 5, 'Rain': 4, 'Light Rain': 3, 'Light Drizzle': 2, 'Drizzle': 1}
+    storm_values = {'Dust storm': 1, 'Lightning Without Thunder': 2, 'Thunderstorm Without Precipitation': 3, 'Thunderstorm': 4}
+    overview = {'Clear': 1, 'Partially cloudy': 2, 'Rain': 2, 'Overcast': 3}
+    
+    df["Rain"] = df['Weather Type'].apply(lambda s: map_weather_to_numerical(s, rain_values))
+    df["Storm"] = df['Weather Type'].apply(lambda s: map_weather_to_numerical(s, storm_values))
+    df["Overview"] = df['Conditions'].apply(lambda s: map_weather_to_numerical(s, overview))
+    
+    # Drop 'Weather Type' and 'Conditions' columns
+    df.drop(["Weather Type", "Conditions"], axis=1, inplace=True)
+    
+    # Convert DATETIME to seconds
+    df["seconds"] = df["DATETIME"].map(pd.Timestamp.timestamp)
+    df.drop("DATETIME", axis=1, inplace=True)
+    
+    # Process seconds to represent periodic nature of days and years
+    day_in_seconds = 24 * 3600
+    year_in_seconds = day_in_seconds * 365.2425
+    df["sin(day)"] = np.sin((df["seconds"] * (2 * np.pi)) / day_in_seconds)
+    df["cos(day)"] = np.cos((df["seconds"] * (2 * np.pi)) / day_in_seconds)
+    df["sin(year)"] = np.sin((df["seconds"] * (2 * np.pi)) / year_in_seconds)
+    df["cos(year)"] = np.cos((df["seconds"] * (2 * np.pi)) / year_in_seconds)
+    df.drop("seconds", axis=1, inplace=True)
+    
+    return df
+

requirements.txt

@@ -0,0 +1,4 @@
+tensorflow
+pandas
+numpy
+gradio