init

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.xlsx filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,24 @@
+# Use Python 3.12.3 base image
+FROM python:3.12.3
+
+# Create a non-root user
+RUN useradd -m -u 1000 user
+
+# Set working directory
+WORKDIR /app
+
+# Copy and install dependencies
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the rest of the application code
+COPY --chown=user . /app
+
+# Switch to the non-root user
+USER user
+
+# Expose the port 7860
+EXPOSE 7860
+
+# Command to run the application with gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:app"]

app.py

@@ -0,0 +1,52 @@
+import torch
+import pandas as pd
+import torch.nn as nn
+
+from flask import Flask, render_template, request
+from model.bilstm import BiLSTM
+
+app = Flask(__name__)
+
+model = BiLSTM.load_from_checkpoint('checkpoints/bilstm_result/epoch=23-step=3456.ckpt', lr=1e-3, num_classes=1, input_size=12)
+model.eval()
+model.freeze()
+
+@app.route('/', methods=['POST', 'GET'])
+def index():
+    if request.method == 'POST':
+        data = {
+            'tau1': [request.form.get('tau1')],
+            'tau2': [request.form.get('tau2')],
+            'tau3': [request.form.get('tau3')],
+            'tau4': [request.form.get('tau4')],
+            'p1': [request.form.get('p1')],
+            'p2': [request.form.get('p2')],
+            'p3': [request.form.get('p3')],
+            'p4': [request.form.get('p4')],
+            'g1': [request.form.get('g1')],
+            'g2': [request.form.get('g2')],
+            'g3': [request.form.get('g3')],
+            'g4': [request.form.get('g4')]
+        }
+
+        df = pd.DataFrame(data).astype('float')
+        X = torch.tensor(df.values.tolist())
+
+        with torch.no_grad():
+            preds = model(X)
+
+        preds = nn.Sigmoid()(preds.squeeze(1))
+        preds = preds.numpy()
+        
+        if preds > 0.5:
+            result = 'Stable'
+
+        else:
+            result = 'Unstable'
+
+        return render_template('index.html', result=result)
+
+    return render_template('index.html')
+    
+if __name__ == '__main__':
+    app.run(debug=True)

checkpoints/bilstm_result/epoch=23-step=3456.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e3ad6ba0bafe6c2afea68eb2a1f36e271dfd3fdfbf90a783f20096a0e67f87c
+size 35048372

main.py

@@ -0,0 +1,29 @@
+import pytorch_lightning as pl
+
+from util.preprocessor import Preprocessor
+from model.bilstm import BiLSTM
+from pytorch_lightning.loggers import TensorBoardLogger
+from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
+
+if __name__ == "__main__":
+    pl.seed_everything(42)
+
+    module = Preprocessor(batch_size=64)
+    num_classes, input_size = module.get_feature_size()
+    
+    model = BiLSTM(lr=1e-3, num_classes=num_classes, input_size=input_size)
+
+    checkpoint_callback = ModelCheckpoint(dirpath='./checkpoints/bilstm_result', monitor='val_loss')
+    logger = TensorBoardLogger('log', name='bilstm_result')
+    early_stop_callback = EarlyStopping(monitor='val_loss', min_delta=0.00, check_on_train_epoch_end=1, patience=10)
+
+    trainer = pl.Trainer(
+        accelerator='gpu',
+        max_epochs=100,
+        default_root_dir='./checkpoints/bilstm_result',
+        callbacks = [checkpoint_callback, early_stop_callback],
+        deterministic=True,
+        logger=logger)
+    
+    trainer.fit(model=model, datamodule=module)
+    trainer.test(model=model, datamodule=module, ckpt_path='best')

model/bilstm.py

@@ -0,0 +1,72 @@
+import torch
+import torch.nn as nn
+import pytorch_lightning as pl
+
+from torchmetrics.classification import BinaryAccuracy
+
+class BiLSTM(pl.LightningModule):
+    def __init__(self, lr, num_classes, input_size, hidden_size=300, num_layers=2, dropout=0.5):
+        super(BiLSTM, self).__init__()
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, bidirectional=True, batch_first=True)
+        self.dropout = nn.Dropout(dropout)
+        self.output_layer = nn.Linear(hidden_size * 2, num_classes)
+        self.criterion = nn.BCEWithLogitsLoss()
+        self.accuracy_metric = BinaryAccuracy()
+        self.lr = lr
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, X):
+        lstm_output, _ = self.lstm(X)
+        preds = self.output_layer(self.dropout(lstm_output))
+
+        return preds
+    
+    def configure_optimizers(self):
+        optimizer = torch.optim.Adam(self.parameters(), lr=self.lr)
+
+        return optimizer
+    
+    def training_step(self, train_batch, batch_idx):
+        X, target = train_batch
+
+        preds = self(X)
+        
+        preds = preds.squeeze(1)
+        loss = self.criterion(preds, target.float())
+        
+        preds = self.sigmoid(preds)
+        accuracy = self.accuracy_metric(preds, target)
+
+        self.log_dict({'train_loss': loss, 'train_accuracy': accuracy}, prog_bar=True, on_epoch=True)
+
+        return loss
+
+    def validation_step(self, valid_batch, batch_idx):
+        X, target = valid_batch
+
+        preds = self(X)
+        
+        preds = preds.squeeze(1)
+        loss = self.criterion(preds, target.float())
+        
+        preds = self.sigmoid(preds)
+        accuracy = self.accuracy_metric(preds, target)
+
+        self.log_dict({'val_loss': loss, 'val_accuracy': accuracy}, prog_bar=True, on_epoch=True)
+
+        return loss
+
+    def test_step(self, test_batch, batch_idx):
+        X, target = test_batch
+
+        preds = self(X)
+        
+        preds = preds.squeeze(1)
+        loss = self.criterion(preds, target.float())
+        
+        preds = self.sigmoid(preds)
+        accuracy = self.accuracy_metric(preds, target)
+
+        self.log_dict({'test_loss': loss, 'test_accuracy': accuracy}, prog_bar=True, on_epoch=True)
+
+        return loss

requirements.txt

@@ -0,0 +1,7 @@
+pytorch_lightning
+gunicorn
+flask
+pandas 
+torch
+imblearn
+sklearn

static/grid.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a4317e3dcb092a541dcff914fbc4fb8525be3f23990d1e9234beb903f9f6763
+size 8802

templates/index.html

@@ -0,0 +1,464 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+    <link
+      href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css"
+      rel="stylesheet"
+      integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC"
+      crossorigin="anonymous"
+    />
+
+    <link
+      href="https://fonts.googleapis.com/css2?family=Quicksand:wght@500&display=swap"
+      rel="stylesheet"
+    />
+
+    <title>Grid Stability Classifier</title>
+    <style>
+      * {
+        font-family: "Quicksand", sans-serif;
+      }
+
+      .product-card {
+        padding: 10px;
+        border: none;
+      }
+
+      .box {
+        transition: 0.5s;
+        border-radius: 20px;
+        width: 300px;
+      }
+
+      .box:hover {
+        transform: translateY(-40px);
+      }
+
+      .card-body {
+        text-align: center;
+      }
+
+      .container {
+        margin-top: 20px;
+      }
+
+      .form-group {
+        margin-bottom: 15px;
+      }
+
+      .btn {
+        background-color: rgba(40, 119, 165, 0.8);
+        border-radius: 15px;
+      }
+
+      .btn-product {
+        color: rgb(255, 255, 255);
+        background-color: rgba(40, 119, 165, 0.8);
+        border-radius: 0px 28.5px 2px;
+        padding: 8px 50px;
+        text-decoration: none;
+      }
+    </style>
+  </head>
+
+  <body>
+    <nav
+      class="navbar navbar-expand navbar-light shadow-sm sticky-top bg-white"
+    >
+      <div
+        class="collapse navbar-collapse justify-content-center"
+        id="navbarSupportedContent"
+      >
+        <ul class="navbar-nav">
+          <li class="nav-item">
+            <a
+              class="nav-link"
+              id="navFeatures"
+              href="#features"
+              onclick="setActiveNav('navFeatures')"
+              >Features</a
+            >
+          </li>
+          <li class="nav-item">
+            <a
+              class="nav-link"
+              id="navClassifier"
+              href="#classifier"
+              onclick="setActiveNav('navClassifier')"
+              >Classifier</a
+            >
+          </li>
+        </ul>
+      </div>
+    </nav>
+
+    <div id="features">
+      <h4 style="text-align: center; margin-top: 30px">Features</h4>
+    </div>
+
+    <div class="container">
+      <div class="product-card shadow rounded p-4">
+        <table class="table">
+          <thead>
+            <tr>
+              <th scope="col">Name</th>
+              <th scope="col" style="text-align: center">Description</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>tau1</td>
+              <td>
+                Electricity producer's reaction time in response to price change
+              </td>
+            </tr>
+            <tr>
+              <td>tau2</td>
+              <td>
+                First consumers' reaction time in response to price change
+              </td>
+            </tr>
+            <tr>
+              <td>tau3</td>
+              <td>
+                Second consumer's reaction time in response to price change
+              </td>
+            </tr>
+            <tr>
+              <td>tau4</td>
+              <td>
+                Third consumer's reaction time in response to price change
+              </td>
+            </tr>
+            <tr>
+              <td>p1</td>
+              <td>
+                Nominal power (positive real) produced by the producer (amount
+                of electricity produced)
+              </td>
+            </tr>
+            <tr>
+              <td>p2</td>
+              <td>
+                Nominal power (negative real) consumed by the first consumer
+                (amount of electricity consumed by the first consumer)
+              </td>
+            </tr>
+            <tr>
+              <td>p3</td>
+              <td>
+                Nominal power (negative real) consumed by the second consumer
+                (amount of electricity consumed by the second consumer)
+              </td>
+            </tr>
+            <tr>
+              <td>p4</td>
+              <td>
+                Nominal power (negative real) consumed by the third consumer
+                (amount of electricity consumed by the third consumer)
+              </td>
+            </tr>
+            <tr>
+              <td>g1</td>
+              <td>
+                (Gamma coefficient) proportional to price elasticity of producer
+              </td>
+            </tr>
+            <tr>
+              <td>g2</td>
+              <td>
+                (Gamma coefficient) proportional to the price elasticity of the
+                first consumer
+              </td>
+            </tr>
+            <tr>
+              <td>g3</td>
+              <td>
+                (Gamma coefficient) proportional to the price elasticity of the
+                second consumer
+              </td>
+            </tr>
+            <tr>
+              <td>g4</td>
+              <td>
+                (Gamma coefficient) proportional to the price elasticity of the
+                third consumer
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </div>
+
+    <div id="classifier">
+      <h4 style="text-align: center; margin-top: 60px">Classifier</h4>
+    </div>
+
+    <div class="container mb-5">
+      <div class="product-card shadow rounded p-4">
+        <form action="/" method="post">
+          <div class="row mb-1">
+            <div class="form-group">
+              <label for="excelFile">Upload Excel File</label>
+              <input
+                type="file"
+                id="excelFile"
+                accept=".xlsx, .xls"
+                class="form-control"
+              />
+              <a
+                style="
+                  float: right;
+                  text-decoration: underline;
+                  color: rgba(40, 119, 165, 0.8);
+                  cursor: pointer;
+                "
+                href="{{ url_for('static', filename='grid.xlsx') }}"
+                >Unduh template excel</a
+              >
+            </div>
+          </div>
+          <p class="text-center">atau</p>
+          <div class="row mt-3">
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>tau1</label>
+                <input
+                  type="text"
+                  name="tau1"
+                  placeholder="tau1"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>tau2</label>
+                <input
+                  type="text"
+                  name="tau2"
+                  placeholder="tau2"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>tau3</label>
+                <input
+                  type="text"
+                  name="tau3"
+                  placeholder="tau3"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>tau4</label>
+                <input
+                  type="text"
+                  name="tau4"
+                  placeholder="tau4"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+          </div>
+
+          <div class="row">
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>p1</label>
+                <input
+                  type="text"
+                  name="p1"
+                  placeholder="p1"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>p2</label>
+                <input
+                  type="text"
+                  name="p2"
+                  placeholder="p2"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>p3</label>
+                <input
+                  type="text"
+                  name="p3"
+                  placeholder="p3"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>p4</label>
+                <input
+                  type="text"
+                  name="p4"
+                  placeholder="p4"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+          </div>
+
+          <div class="row">
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>g1</label>
+                <input
+                  type="text"
+                  name="g1"
+                  placeholder="g1"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>g2</label>
+                <input
+                  type="text"
+                  name="g2"
+                  placeholder="g2"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>g3</label>
+                <input
+                  type="text"
+                  name="g3"
+                  placeholder="g3"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+            <div class="col-md-3">
+              <div class="form-group">
+                <label>g4</label>
+                <input
+                  type="text"
+                  name="g4"
+                  placeholder="g4"
+                  class="form-control"
+                  required
+                />
+              </div>
+            </div>
+          </div>
+
+          <div class="d-flex justify-content-center mt-4">
+            <button type="submit" class="btn btn-primary w-50">Classify</button>
+          </div>
+        </form>
+      </div>
+    </div>
+    <script src="https://cdn.jsdelivr.net/npm/sweetalert2@10"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js"></script>
+    <script
+      src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js"
+      integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM"
+      crossorigin="anonymous"
+    ></script>
+    <script>
+      {% if result %}
+        Swal.fire({
+          title: 'Classification Result',
+          text: '{{ result }}',
+          icon: 'info',
+          confirmButtonColor: '#3085d6',
+          confirmButtonText: 'OK'
+        });
+      {% endif %}
+    </script>
+    <script>
+      document
+        .getElementById("excelFile")
+        .addEventListener("change", handleFile, false);
+
+      function handleFile(event) {
+        const file = event.target.files[0];
+        if (!file) return;
+
+        const reader = new FileReader();
+        reader.onload = function (e) {
+          const data = new Uint8Array(e.target.result);
+          const workbook = XLSX.read(data, { type: "array" });
+
+          const sheetName = workbook.SheetNames[0];
+          const sheet = workbook.Sheets[sheetName];
+          const json = XLSX.utils.sheet_to_json(sheet, { header: 1 });
+
+          populateForm(json);
+        };
+        reader.readAsArrayBuffer(file);
+      }
+
+      function populateForm(data) {
+        const fields = data[0];
+        const values = data[1];
+
+        fields.forEach((field, index) => {
+          const input = document.querySelector(`[name="${field}"]`);
+
+          if (values[index] == undefined) {
+            values[index] = 0;
+          }
+
+          if (input) {
+            input.value = values[index];
+          }
+        });
+      }
+
+      function filterNumericInput(event) {
+        const input = event.target;
+        let value = input.value;
+
+        // Remove all characters except digits and decimal point
+        value = value.replace(/[^0-9.]/g, "");
+
+        // Remove multiple decimal points
+        const parts = value.split(".");
+        if (parts.length > 2) {
+          value = parts[0] + "." + parts.slice(1).join("");
+        }
+
+        input.value = value;
+      }
+
+      // Attach the filter function to all number input fields
+      document.querySelectorAll('input[type="text"]').forEach((input) => {
+        input.addEventListener("input", filterNumericInput);
+      });
+    </script>
+  </body>
+</html>

util/preprocessor.py

@@ -0,0 +1,104 @@
+import os
+import torch
+import multiprocessing
+import pandas as pd
+import pytorch_lightning as pl
+
+from sklearn.model_selection import train_test_split
+from torch.utils.data import TensorDataset, DataLoader
+from imblearn.over_sampling import SMOTE
+
+
+class Preprocessor(pl.LightningDataModule):
+    def __init__(self, batch_size):
+        super(Preprocessor, self).__init__()    
+        self.dataset = pd.read_csv('dataset/simulated_electrical_grid.csv')
+        self.batch_size = batch_size
+        self.oversampling = SMOTE(random_state=42)
+
+    def setup(self, stage=None):
+        train_set, valid_set, test_set = self.preprocessor()   
+        if stage == "fit":
+            self.train_set = train_set
+            self.valid_set = valid_set
+        elif stage == "test":
+            self.test_set = test_set
+
+    def train_dataloader(self):
+        return DataLoader(
+            dataset=self.train_set,
+            batch_size=self.batch_size,
+            shuffle=True,
+            num_workers=multiprocessing.cpu_count()
+        )
+    
+    def val_dataloader(self):
+        return DataLoader(
+            dataset=self.valid_set,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=multiprocessing.cpu_count()
+        )
+
+    def test_dataloader(self):
+        return DataLoader(
+            dataset=self.test_set,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=multiprocessing.cpu_count()
+        )
+
+    def preprocessor(self):
+        if os.path.exists("dataset/train_set.pt") and os.path.exists("dataset/valid_set.pt") and os.path.exists("dataset/test_set.pt"):
+            print("\nLoading Data...")
+            train_set = torch.load("dataset/train_set.pt")
+            valid_set = torch.load("dataset/valid_set.pt")
+            test_set = torch.load("dataset/test_set.pt")
+            print('[ Loading Completed ]\n')
+
+        else:
+            print("\nPreprocessing Data...")
+            train_set, valid_set, test_set = self.preprocessing_data(self.dataset)
+            print('[ Preprocessing Completed ]\n')
+
+        return train_set, valid_set, test_set
+    
+    def preprocessing_data(self, dataset):
+        X = dataset[['tau1', 'tau2', 'tau3', 'tau4', 'p1', 'p2', 'p3', 'p4', 'g1', 'g2', 'g3', 'g4']]
+        y = dataset['stabf']
+
+        X_train_res, y_train_res = self.oversampling.fit_resample(X, y)
+        y_train_res = self.label_encoding(y_train_res)
+
+        X_train_valid, X_test, y_train_valid, y_test = train_test_split(X_train_res, y_train_res, test_size=0.2, random_state=42)
+        X_train, X_valid, y_train, y_valid = train_test_split(X_train_valid, y_train_valid, test_size=0.1, random_state=42)
+    
+        X_train_tensor = torch.tensor(X_train.values.tolist())
+        y_train_tensor = torch.tensor(y_train.values.tolist())
+        
+        X_valid_tensor = torch.tensor(X_valid.values.tolist())
+        y_valid_tensor = torch.tensor(y_valid.values.tolist())
+        
+        X_test_tensor = torch.tensor(X_test.values.tolist())
+        y_test_tensor = torch.tensor(y_test.values.tolist())
+
+        train_set = TensorDataset(X_train_tensor, y_train_tensor)
+        valid_set = TensorDataset(X_valid_tensor, y_valid_tensor)
+        test_set = TensorDataset(X_test_tensor, y_test_tensor)
+    
+        torch.save(train_set, "dataset/train_set.pt")
+        torch.save(valid_set, "dataset/valid_set.pt")
+        torch.save(test_set, "dataset/test_set.pt")
+
+        return train_set, valid_set, test_set
+
+    def label_encoding(self, y_train):
+        encoder = {'unstable': 0, 'stable': 1}
+        y_train = y_train.astype('str').map(encoder)
+
+        return y_train
+
+    def get_feature_size(self):
+        X = self.dataset[['tau1','tau2','tau3','tau4','p1', 'p2', 'p3', 'p4','g1','g2','g3','g4']]
+        
+        return 1, len(X.columns.tolist())