weather

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/aieye_tutorial_template.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,27 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPep8Inspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="E402" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N806" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="trx_clus" />
+          <option value="matrix_demand_transfer" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/aieye_tutorial_template.iml" filepath="$PROJECT_DIR$/.idea/aieye_tutorial_template.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

0_Introduction.py

@@ -8,17 +8,25 @@ initialize_level()
 LEVEL=0
 
 def intro_page():
-    st.header("AI Eye Tutorial Template")
-    st.subheader("Level 0: Introduction")
+    st.header("Weather Forecasting")
+    st.subheader("Introduction")
 
-    st.write("""Welcome to the AI Eye Tutorial Template! This template is designed to help you create your own AI Eye tutorial.
-    The template is divided into levels, and each level has a set of tasks that you need to complete before you can move on to the next level.
-    You can use this template to create your own tutorial by completing the tasks in each level and adding your own content. You can also use 
-    this template to learn how to use AI Eye by completing the tasks in each level.""")
+    st.write("""Welcome to the interactive tutorial on creating your very own Weather Forecasting Application!""")
 
-    st.info(f"Current Level: {get_level()}")
+    st.image(
+        "https://www.beckwithweather.com/wp-content/uploads/sites/1134/2020/06/860_main_weather_and_prediction.png",
+        use_column_width=True,
+    )
 
-    if st.button("Complete"):
+    st.write(
+        """
+        In this tutorial, you will learn how to build a simple application that can forecast weather conditions to make informed decisions. Weather forecasting plays a pivotal role in our daily lives, influencing our travel plans, agricultural activities, energy consumption, and overall decision-making.
+    """
+    )
+
+    st.info(f"Click on the button below to start the tutorial!")
+
+    if st.button("I am Ready!"):
         complete_level(LEVEL)
 
 render_page(intro_page, LEVEL)

pages/1_Step_1.py

@@ -1,15 +0,0 @@
-import streamlit as st
-from utils.levels import complete_level, render_page, initialize_level
-LEVEL = 1
-
-initialize_level()
-
-def step1_page():
-    st.header("Step 1")
-    st.subheader("Level 1: Introduction")
-    st.write("This is the first step of the tutorial. You can add your own content here.")
-
-    if st.button("Complete"):
-        complete_level(LEVEL)
-
-render_page(step1_page, LEVEL)

pages/1_Weather Forecasting and It's Applications.py

@@ -0,0 +1,58 @@
+import streamlit as st
+from utils.levels import complete_level, render_page, initialize_level
+LEVEL = 1
+
+initialize_level()
+
+def step1_page():
+    st.header("Weather Forecasting and It's Applications")
+    st.markdown(
+    """
+    ### What is weather forecasting?
+    Weather forecasting is an application of science and advanced technology that is used to predict the atmospheric condition 
+    for an upcoming point of time and a given location. 
+
+    Our day to day life is directly or indirectly depends on the weather in terms of economy and environment, 
+    it affects us with various factors as events, timing, duration, location, etc. In consideration of these factors, 
+    weather forecasting works with the parameters temperature, humidity, and wind speed. 
+    
+    ### Applications of weather forecasting
+    Weather forecasting has numerous real-world applications across various industries and sectors. 
+    Its impact extends beyond personal planning and extends to critical decision-making processes in sectors that heavily rely on weather conditions. 
+    Here are some key applications of weather forecasting in the real world:
+    
+    1. **Aviation Industry**: Weather forecasting plays a vital role in aviation, enabling pilots and airlines to plan safe flight routes, avoid turbulence, and make decisions regarding takeoff, landing, and flight diversions based on current and predicted weather conditions.
+
+    2. **Agriculture and Farming**: Farmers use weather forecasts to optimize irrigation schedules, plan planting and harvesting activities, and protect crops from adverse weather conditions, such as frost, drought, or excessive rainfall.
+
+    3. **Energy and Utilities**: Weather forecasts are crucial for energy and utility companies to anticipate electricity demand, especially for renewable energy sources like solar and wind power, which are highly dependent on weather patterns.
+
+    4. **Transportation and Logistics**: Weather forecasts help transportation and logistics companies plan routes, manage schedules, and anticipate potential disruptions due to adverse weather conditions, ensuring efficient and reliable services.
+
+    5. **Disaster Management and Emergency Response**: Accurate weather predictions aid disaster management agencies in preparing for and responding to natural disasters like hurricanes, floods, and wildfires. It allows for timely evacuations and resource allocation to mitigate the impact of extreme weather events.
+
+    6. **Tourism and Hospitality**: The tourism industry relies on weather forecasts to manage tourist activities, plan outdoor events, and optimize resource allocation for hotels and resorts based on expected weather conditions.
+
+    7. **Construction Industry**: Weather forecasts are essential for construction companies to plan construction schedules, especially for outdoor projects that are susceptible to weather-related delays and safety risks.
+
+    8. **Retail and Sales**: Weather predictions impact consumer behavior, influencing purchases of seasonal items like clothing, outdoor equipment, and home appliances.
+
+    9. **Public Health**: Weather forecasts help public health agencies anticipate and prepare for weather-related health risks, such as heatwaves, air pollution, and disease outbreaks.
+
+    10. **Environmental Monitoring**: Weather forecasting is essential for monitoring and understanding weather-related environmental changes, including climate trends, sea-level rise, and extreme weather occurrences.
+
+    11. **Sports and Events**: Weather forecasts play a significant role in organizing outdoor sports events, concerts, and festivals, ensuring the safety and comfort of participants and attendees.
+
+    12. **Media and News Reporting**: Weather forecasts are frequently featured in media to keep the public informed about upcoming weather conditions and potential weather-related impacts.
+
+    Throughout the tutorial, you will learn how weather forecasting works and will have the opportunity to implement a robust weather forecasting application by yourself!. 
+    Step by step, we will guide you through the process, ensuring that you gain a deep understanding of each concept and its practical implementation.
+    """
+    )
+
+    st.info("Click on the button below to continue!")
+
+    if st.button("Complete"):
+        complete_level(LEVEL)
+
+render_page(step1_page, LEVEL)

pages/2_Step_2.py

@@ -1,16 +0,0 @@
-import streamlit as st
-from utils.levels import complete_level, render_page, initialize_level
-
-initialize_level()
-
-LEVEL = 2
-
-def step2_page():
-    st.header("Step 2")
-    st.subheader("Level 2: Introduction")
-    st.write("This is the second step of the tutorial. You can add your own content here.")
-
-    if st.button("Complete"):
-        complete_level(LEVEL)
-
-render_page(step2_page, LEVEL)

pages/2_Technology Behind It.py

@@ -0,0 +1,52 @@
+import streamlit as st
+from utils.levels import complete_level, render_page, initialize_level
+
+initialize_level()
+
+LEVEL = 2
+
+def step2_page():
+    st.header("Technology Behind It")
+    st.markdown(
+    """
+    ### How machine learning is used for accurate weather forecasting?
+    Traditional numerical weather prediction models have been the cornerstone of meteorology for decades, relying on 
+    complex physical equations and extensive observational data. 
+    
+    However, the rise of machine learning has brought a paradigm shift to weather forecasting, unlocking new possibilities and enhanced accuracy in predicting atmospheric phenomena. 
+    Machine learning techniques leverage the power of algorithms to identify patterns and relationships within vast and complex weather datasets. 
+    By learning from historical weather data, machine learning models can capture hidden patterns and non-linear relationships that might be 
+    challenging to represent using traditional methods. This empowers meteorologists and researchers to create highly sophisticated and 
+    precise forecasting models that can make predictions for various temporal scales, from short-term weather conditions to long-term climate trends.
+
+    Here's how it works:
+    1. **Data Collection**: The first step is to collect large amounts of historical weather data, which includes various atmospheric parameters like temperature, humidity, wind speed, pressure, solar irradiance, and more. This data is typically obtained from weather stations, satellites, radars, and other sources.
+
+    2. **Data Preprocessing**: The collected data needs to be preprocessed to handle missing values, outliers, and inconsistencies. It may involve data cleaning, imputation, and scaling to ensure that the data is suitable for training machine learning models.
+    
+    3. **Feature Engineering:**: In weather forecasting, relevant features play a crucial role in accurate predictions. Engineers and meteorologists work together to extract meaningful features from the raw data, which could include time-based features (e.g., day of the week, month), lagged values (to capture temporal dependencies), geographic features (latitude, longitude), and more.
+    
+    4. **Data Splitting**: The preprocessed data is split into training and testing sets. The training set is used to train the machine learning model, and the testing set is used to evaluate its performance.
+    
+    5. **Model Selection**:  Different machine learning algorithms can be used for weather forecasting, such as regression models (e.g., linear regression), time series models (e.g., ARIMA, SARIMA), and more advanced models like decision trees, random forests, gradient boosting, and neural networks. The choice of model depends on the characteristics of the data and the forecasting task.
+    
+    6. **Model Training**: The selected machine learning model is trained on the training data. During training, the model learns from the historical data and tries to capture patterns and relationships between the input features (e.g., temperature, humidity) and the target variable (e.g., future temperature).
+    
+    7. **Model Evaluation**: After training, the model's performance is evaluated using the testing data. Common evaluation metrics for weather forecasting include mean absolute error (MAE), mean squared error (MSE), root mean squared error (RMSE), and correlation coefficients.
+    
+    8. **Forecasting**: Once the model is trained and evaluated, it can be used to make predictions for future weather conditions based on new input data. For example, given current weather conditions and historical data, the model can forecast the weather for the next few hours or days.
+    
+    9. **Updating and Re-training**: Weather data is constantly changing, so the forecasting model needs to be updated regularly with new data. Periodic re-training of the model ensures that it stays up-to-date and continues to make accurate predictions.
+    
+    """
+    )
+
+    st.image(
+        "https://miro.medium.com/v2/resize:fit:720/format:webp/1*mRpdRbCta8VWlTrx12WNOQ.jpeg",
+        use_column_width=True,
+    )
+
+    if st.button("Complete"):
+        complete_level(LEVEL)
+
+render_page(step2_page, LEVEL)

pages/3_Training the Model.py

@@ -0,0 +1,192 @@
+import time
+from utils.levels import complete_level, render_page, initialize_level
+from utils.login import get_login, initialize_login
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import r2_score
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import RandomizedSearchCV
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import RendererAgg
+_lock = RendererAgg.lock
+import base64
+from io import BytesIO
+from PIL import Image, ImageFilter
+import lightgbm as lgb
+
+initialize_login()
+initialize_level()
+
+LEVEL = 3
+
+File_PATH = 'datasets/Building_forcasting.csv'
+
+def process_file(csv_file):
+    data = pd.read_csv(csv_file, index_col='Timestamp')
+    data.index = pd.to_datetime(data.index)
+    data = data.fillna(0)
+    return data
+
+
+def model_predict(data, model_choice, train_size, tune_model):
+    if model_choice == 'LightGBM':
+        model = lgb.LGBMRegressor() if not tune_model else lgb.LGBMRegressor(**tuned_parameters('lgbm'))
+    elif model_choice == 'Random Forest':
+        model = RandomForestRegressor(n_estimators=100, random_state=42) if not tune_model else RandomForestRegressor(**tuned_parameters('rf'))
+
+    X, y = create_model_inputs(data, 288, 288)
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=train_size/100, random_state=42, shuffle=False)
+
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+
+    return y_test, y_pred, model
+
+
+def create_model_inputs(data, lag, mean_period):
+    df_processed = data.copy()
+    df_processed['PV_Output_lag'] = df_processed['PV_Output'].shift(lag)
+    df_processed['PV_Output_mean'] = df_processed['PV_Output'].rolling(window=mean_period).mean()
+
+    X = df_processed[['Solar_Irradiance', 'Temperature', 'Rain_Fall', 'Wind_speed', 'PV_Output_lag', 'PV_Output_mean']].dropna()
+    y = df_processed[['PV_Output']].loc[X.index]
+
+    return X, y
+
+
+def show_output(y_test, y_pred):
+    st.sidebar.subheader("Model Performance")
+    st.sidebar.write(f"Test R2 score: {r2_score(y_test, y_pred):.2f}")
+
+    fig, axs = plt.subplots(3, figsize=(12, 18))
+    axs[0].plot(y_test.index, y_pred/1000, label='Predicted')
+    axs[0].plot(y_test.index, y_test['PV_Output']/1000, label='Actual')
+    axs[0].legend()
+    axs[0].set_title('Prediction vs Actual (Solar Power Generation)')
+    axs[0].set_xlabel('Date')
+    axs[0].set_ylabel('Solar Power Generation (kW)')
+
+    axs[1].plot(y_test.index, y_pred/1000, label='Predicted')
+    axs[1].set_title('Predicted Solar Power Generation')
+    axs[1].set_xlabel('Date')
+    axs[1].set_ylabel('Solar Power Generation (kW)')
+
+    axs[2].plot(y_test.index, y_test['PV_Output']/1000, label='Actual')
+    axs[2].set_title('Actual Solar Power Generation')
+    axs[2].set_xlabel('Date')
+    axs[2].set_ylabel('Solar Power Generation (kW)')
+
+    fig.tight_layout()
+    with _lock:
+        st.pyplot(fig)
+
+    return fig
+
+
+def download_link(y_test, y_pred):
+    y_pred_df = pd.DataFrame({'Timestamp': y_test.index, 'Predicted_Power': y_pred, 'Actual_Total_Power_(kW)': y_test['PV_Output']})
+    csv = y_pred_df.to_csv(index=False)
+    b64 = base64.b64encode(csv.encode()).decode()
+    href = f'<a href="data:file/csv;base64,{b64}" download="Predicted_Solar_Power.csv">Download Predicted Power CSV File</a>'
+    st.sidebar.markdown(href, unsafe_allow_html=True)
+
+
+def feature_importance_plot(model, feature_names):
+    # Get feature importances
+    importance = model.feature_importances_
+    # Normalize by the sum of all importances
+    importance = 100.0 * (importance / importance.sum())
+    plt.figure(figsize=(10, 6))
+    plt.bar(feature_names, importance)
+    plt.title('Feature Importance')
+    plt.xlabel('Features')
+    plt.ylabel('Importance (%)')
+    return plt.gcf()
+
+
+def download_plot(fig):
+    tmpfile = BytesIO()
+    fig.savefig(tmpfile, format='png')
+    encoded = base64.b64encode(tmpfile.getvalue()).decode('utf-8')
+
+    href = f'<a href="data:image/png;base64,{encoded}" download="plot.png">Download Result Plot</a>'
+    st.sidebar.markdown(href, unsafe_allow_html=True)
+
+
+def tuned_parameters(model):
+    if model == 'lgbm':
+        params = {
+            'num_leaves': [10, 20, 30, 40, 50],
+            'max_depth': [-1, 3, 5, 10],
+            'learning_rate': [0.01, 0.05, 0.1],
+            'n_estimators': [100, 500, 1000]
+        }
+        return params
+
+    elif model == 'rf':
+        params = {
+            'n_estimators': [10, 100, 500, 1000],
+            'max_depth': [None, 10, 20, 30, 40, 50],
+            'min_samples_split': [2, 5, 10],
+            'min_samples_leaf': [1, 2, 4]
+        }
+        return params
+
+def step3_page():
+    st.header("Training the Model")
+    st.subheader("Exploring the data")
+    st.title("Solar Forecasting App")
+
+    # Display the image and information in a grid layout
+    col1 = st.columns([1])
+
+    with col1[0]:
+        data = {
+            'Timestamp': ['11/1/2022 0:20', '11/1/2022 0:25'],
+            'Total_Power (kW)': [37337, 44590],
+            'PV_Output': [296.6, 298.4],
+            'Solar_Irradiance': [0, 0],
+            'Temperature': [25.1, 24.7],
+            'Rain_Fall': [42.6, 42.6],
+            'Wind_Speed': [0.6, 0.4]
+        }
+        df = pd.DataFrame(data)
+        st.subheader("Example of CSV file DataFrame")
+        st.table(df)
+
+    csv_file = st.sidebar.file_uploader("Upload CSV", type=['csv'])
+
+    if csv_file is not None:
+        data = process_file(csv_file)
+
+        train_size = st.sidebar.slider("Select Train Dataset Size (%)", min_value=10, max_value=90, value=70)
+
+        models = ['LightGBM', 'Random Forest']
+        model_choice = st.sidebar.selectbox('Choose Model', models)
+
+        tune_model = st.sidebar.checkbox('Tune Hyperparameters')
+
+        y_test, y_pred, model = model_predict(data, model_choice, train_size, tune_model)
+
+        # Display feature importance
+        if st.sidebar.checkbox('Show feature importance'):
+            feature_names = ['Solar_Irradiance', 'Temperature', 'Rain_Fall', 'Wind_speed', 'PV_Output_lag',
+                             'PV_Output_mean']
+            fig = feature_importance_plot(model, feature_names)
+            with _lock:
+                st.pyplot(fig)
+
+        fig = show_output(y_test, y_pred)
+
+        download_link(y_test, y_pred)
+
+        download_plot(fig)
+
+    if st.button("Complete"):
+        complete_level(LEVEL)
+
+
+render_page(step3_page, LEVEL)

requirements.txt

@@ -1 +1,6 @@
-firebase_admin
+firebase_admin
+scikit-learn
+lightgbm
+matplotlib
+streamlit-pandas-profiling
+pyngrok