Upload 12 files

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+COPY best_llm_model-16.pt .
+COPY scalers/ ./scalers/
+
+EXPOSE 8501
+
+CMD ["streamlit", "run", "app.py"] 

README copy.md

@@ -0,0 +1,51 @@
+---
+title: Fricitonangle prediction of solid waste
+emoji: 🚗
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: "1.29.0"
+app_file: app.py
+pinned: false
+---
+
+
+# Waste Properties Predictor
+
+This Streamlit app predicts both friction angle and cohesion based on waste composition and characteristics using deep learning models.
+
+## Features
+
+- Predicts both friction angle and cohesion simultaneously
+- Supports Excel file input for batch predictions
+- Provides SHAP value explanations for predictions
+- Interactive input interface with value range validation
+- Supports custom data upload
+
+## Files Description
+
+- `app.py`: Main application file
+- `requirements.txt`: Required Python packages
+- `friction_model.pt`: Pre-trained model for friction angle prediction
+- `cohesion_model.pt`: Pre-trained model for cohesion prediction
+- `Data_syw.xlsx`: Default data file with example values
+
+## Usage
+
+1. The app loads with default values from the first row of `Data_syw.xlsx`
+2. You can either:
+   - Use the default values
+   - Upload your own Excel file with waste composition data
+   - Manually adjust individual values using the input fields
+3. Click "Predict Properties" to get predictions and SHAP explanations
+
+## Input Parameters
+
+The app accepts various waste composition and characteristic parameters. All inputs are validated against the training data ranges to ensure reliable predictions.
+
+## Output
+
+For each prediction, the app provides:
+- Predicted friction angle (degrees)
+- Predicted cohesion (kPa)
+- SHAP waterfall plots explaining the contribution of each feature to the predictions 

README.md

@@ -1,13 +1,49 @@
----
-title: Concrete Creep
-emoji: 📈
-colorFrom: blue
-colorTo: green
-sdk: streamlit
-sdk_version: 1.44.1
-app_file: app.py
-pinned: false
-short_description: concrete_creep
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Concrete Creep Prediction App
+
+A Streamlit application to predict concrete creep strain over time using a specialized LLM-style model.
+
+## Deployment Instructions
+
+### Prerequisites
+- Python 3.8 or higher
+- pip for package installation
+
+### Installation
+
+1. Clone or download this repository
+
+2. Install the required packages:
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Run the Streamlit app:
+   ```
+   streamlit run app.py
+   ```
+
+## How to Use
+
+1. Open the app in your web browser (typically at http://localhost:8501)
+2. Adjust the concrete properties using the sidebar controls:
+   - Density (kg/m³)
+   - Compressive Strength (MPa)
+   - Elastic Modulus (MPa)
+   - Initial Creep Value
+3. Set the desired time range for prediction
+4. Click "Predict Creep Strain" to generate results
+5. View the prediction charts and download the results as CSV if needed
+
+## Files
+
+- `app.py`: Standalone application code
+- `requirements.txt`: Required Python packages
+- `best_llm_model-16.pt`: Pre-trained model
+- `scalers/`: Directory containing normalization scalers
+  - `feature_scaler.pkl`: Scaler for input features
+  - `creep_scaler.pkl`: Scaler for creep values
+  - `time_values.pkl`: Time values for prediction
+
+## Model Information
+
+The application uses a specialized LLM-style transformer model to predict concrete creep strain based on concrete properties (density, compressive strength, and elastic modulus). The model performs autoregressive prediction to estimate creep over time. 

app.py

@@ -0,0 +1,625 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+import matplotlib.pyplot as plt
+import pickle
+import os
+import math
+
+# Set page config
+st.set_page_config(
+    page_title="Concrete Creep Prediction",
+    page_icon="🏗️",
+    layout="wide"
+)
+
+# Display logo
+st.image("AI_logo.png", width=200)
+
+# Define custom scaler classes
+class CreepScaler:
+    def __init__(self, factor=1000):
+        self.factor = factor
+        self.mean_ = 0  # Default to no mean shift
+        self.scale_ = factor  # Use factor as scale
+        self.is_standard_scaler = False
+    
+    def transform(self, X):
+        if isinstance(X, np.ndarray):
+            if self.is_standard_scaler:
+                return (X - self.mean_) / self.scale_
+            return X / self.factor
+        return np.array(X) / self.factor
+    
+    def inverse_transform(self, X):
+        if isinstance(X, np.ndarray):
+            if self.is_standard_scaler:
+                return (X * self.scale_) + self.mean_
+            return X * self.factor
+        return np.array(X) * self.factor
+
+# Positional Encoding for Transformer
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        
+        self.register_buffer('pe', pe)
+        
+    def forward(self, x):
+        # x: [batch_size, seq_len, d_model]
+        return x + self.pe[:x.size(1), :].unsqueeze(0)
+
+# Feature Encoder for static features
+class FeatureEncoder(nn.Module):
+    def __init__(self, input_dim, hidden_dim, dropout=0.1):
+        super(FeatureEncoder, self).__init__()
+        
+        # Original encoding path
+        self.fc1 = nn.Linear(input_dim, hidden_dim * 2)
+        self.ln1 = nn.LayerNorm(hidden_dim * 2)
+        self.fc2 = nn.Linear(hidden_dim * 2, hidden_dim)
+        self.ln2 = nn.LayerNorm(hidden_dim)
+        
+        # New feature-wise projection (each feature to dim 16)
+        self.feature_projection = nn.Linear(1, 16)
+        
+        # Ensure feature attention is configured correctly
+        feature_embed_dim = 16
+        # For 16 dimensions, valid num_heads are: 1, 2, 4, 8, 16
+        feature_heads = 4  # 16 is divisible by 4
+        
+        # Attention for parallel feature processing
+        self.feature_attention = nn.MultiheadAttention(
+            embed_dim=feature_embed_dim,
+            num_heads=feature_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        
+        # For batch attention, first choose the embedding dimension
+        # Make it a power of 2 for compatibility with many head configurations
+        batch_embed_dim = 16  # Fixed safe value, divisible by many head counts
+        
+        # Now choose heads that divide evenly into the embed_dim
+        batch_heads = 4  # 16 is divisible by 4
+        
+        # Always project input to the fixed batch_embed_dim
+        self.batch_projection = nn.Linear(input_dim, batch_embed_dim)
+        
+        # Batch-wise attention with safe values
+        self.batch_attention = nn.MultiheadAttention(
+            embed_dim=batch_embed_dim,
+            num_heads=batch_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        
+        # Layer norms for attention outputs
+        self.feature_ln = nn.LayerNorm(16)
+        self.batch_ln = nn.LayerNorm(batch_embed_dim)
+        
+        # Integration layer - combines original and new paths
+        self.integration = nn.Linear(hidden_dim + 16 * input_dim + batch_embed_dim, hidden_dim)
+        self.integration_ln = nn.LayerNorm(hidden_dim)
+        
+        self.dropout = nn.Dropout(dropout)
+        self.relu = nn.ReLU()
+        
+        # Store dimensions for debugging
+        self.input_dim = input_dim
+        self.batch_embed_dim = batch_embed_dim
+        self.batch_heads = batch_heads
+        
+        print(f"FeatureEncoder initialized with: input_dim={input_dim}, batch_embed_dim={batch_embed_dim}, batch_heads={batch_heads}")
+        
+    def forward(self, x):
+        # x: [batch_size, input_dim]
+        batch_size, input_dim = x.size()
+        
+        # Original path
+        original = self.fc1(x)
+        original = self.ln1(original)
+        original = self.relu(original)
+        original = self.dropout(original)
+        
+        original = self.fc2(original)
+        original = self.ln2(original)
+        original = self.relu(original)
+        
+        # Feature-wise projection path
+        # Reshape to process each feature separately
+        features = x.view(batch_size, input_dim, 1)  # [batch_size, input_dim, 1]
+        features_projected = self.feature_projection(features)  # [batch_size, input_dim, 16]
+        
+        # Feature-wise attention
+        feature_attn_out, _ = self.feature_attention(
+            features_projected, 
+            features_projected, 
+            features_projected
+        )  # [batch_size, input_dim, 16]
+        feature_attn_out = self.feature_ln(feature_attn_out + features_projected)  # Add & Norm
+        
+        # Apply projection to make input_dim compatible with attention
+        x_proj = self.batch_projection(x)
+        
+        # Batch-wise attention
+        batch_attn_out, _ = self.batch_attention(
+            x_proj.unsqueeze(1),  # [batch_size, 1, batch_embed_dim] 
+            x_proj.unsqueeze(1), 
+            x_proj.unsqueeze(1)
+        )  # [batch_size, 1, batch_embed_dim]
+        batch_attn_out = self.batch_ln(batch_attn_out.squeeze(1) + x_proj)  # Add & Norm
+        
+        # Reshape feature attention output to concatenate
+        feature_attn_flat = feature_attn_out.reshape(batch_size, -1)  # [batch_size, input_dim * 16]
+        
+        # Concatenate all processed features
+        combined = torch.cat([original, feature_attn_flat, batch_attn_out], dim=1)
+        
+        # Final integration
+        output = self.integration(combined)
+        output = self.integration_ln(output)
+        output = self.relu(output)
+        
+        return output
+
+# Self-Attention Block
+class SelfAttention(nn.Module):
+    def __init__(self, d_model, num_heads, dropout=0.1):
+        super(SelfAttention, self).__init__()
+        self.d_model = d_model
+        self.num_heads = num_heads
+        self.head_dim = d_model // num_heads
+        
+        assert self.head_dim * num_heads == d_model, "d_model must be divisible by num_heads"
+        
+        # Multi-head attention
+        self.attention = nn.MultiheadAttention(
+            embed_dim=d_model,
+            num_heads=num_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        
+        # Layer normalization and dropout
+        self.layer_norm = nn.LayerNorm(d_model)
+        self.dropout = nn.Dropout(dropout)
+        
+    def forward(self, x, attention_mask=None, key_padding_mask=None):
+        # x: [batch_size, seq_len, d_model]
+        
+        # Self-attention with residual connection
+        attn_output, _ = self.attention(
+            query=x, 
+            key=x, 
+            value=x,
+            attn_mask=attention_mask,
+            key_padding_mask=key_padding_mask
+        )
+        
+        # Add & Norm
+        x = x + self.dropout(attn_output)
+        x = self.layer_norm(x)
+        
+        return x
+
+# Feed-Forward Block
+class FeedForward(nn.Module):
+    def __init__(self, d_model, d_ff, dropout=0.1):
+        super(FeedForward, self).__init__()
+        
+        self.linear1 = nn.Linear(d_model, d_ff)
+        self.linear2 = nn.Linear(d_ff, d_model)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+        self.layer_norm = nn.LayerNorm(d_model)
+        
+    def forward(self, x):
+        # x: [batch_size, seq_len, d_model]
+        
+        # FFN with residual connection
+        ff_output = self.linear1(x)
+        ff_output = self.relu(ff_output)
+        ff_output = self.dropout(ff_output)
+        ff_output = self.linear2(ff_output)
+        
+        # Add & Norm
+        x = x + self.dropout(ff_output)
+        x = self.layer_norm(x)
+        
+        return x
+
+# Transformer Encoder Layer
+class EncoderLayer(nn.Module):
+    def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
+        super(EncoderLayer, self).__init__()
+        
+        self.self_attention = SelfAttention(d_model, num_heads, dropout)
+        self.feed_forward = FeedForward(d_model, d_ff, dropout)
+        
+    def forward(self, x, attention_mask=None, key_padding_mask=None):
+        # x: [batch_size, seq_len, d_model]
+        
+        # Self-attention block
+        x = self.self_attention(x, attention_mask, key_padding_mask)
+        
+        # Feed-forward block
+        x = self.feed_forward(x)
+        
+        return x
+
+# LLM-Style Concrete Creep Transformer
+class LLMConcreteModel(nn.Module):
+    def __init__(
+        self, 
+        feature_dim, 
+        d_model=128, 
+        num_layers=6,
+        num_heads=8,
+        d_ff=512,
+        dropout=0.1,
+        target_len=1
+    ):
+        super(LLMConcreteModel, self).__init__()
+        
+        # Model dimensions
+        self.d_model = d_model
+        self.target_len = target_len
+        
+        # Input embedding layers
+        self.creep_embedding = nn.Linear(1, d_model)
+        self.time_embedding = nn.Linear(1, d_model) if True else None  # Optional time embedding
+        self.feature_encoder = FeatureEncoder(feature_dim, d_model, dropout)
+        
+        # Positional encoding
+        self.positional_encoding = PositionalEncoding(d_model)
+        
+        # Encoder layers
+        self.encoder_layers = nn.ModuleList([
+            EncoderLayer(d_model, num_heads, d_ff, dropout)
+            for _ in range(num_layers)
+        ])
+        
+        # Output layers for prediction
+        self.predictor = nn.Sequential(
+            nn.Linear(d_model, d_model),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(d_model, target_len)
+        )
+        
+        # Integration of features with sequence
+        self.feature_integration = nn.Linear(d_model * 2, d_model)
+        
+        # Layer normalization
+        self.layer_norm = nn.LayerNorm(d_model)
+        
+        # Dropout
+        self.dropout = nn.Dropout(dropout)
+        
+    def forward(self, creep_history, features, lengths, time_history=None):
+        # creep_history: [batch_size, max_seq_len]
+        # features: [batch_size, feature_dim]
+        # lengths: [batch_size] - actual sequence lengths
+        # time_history: [batch_size, max_seq_len] (optional)
+        
+        # Get the device from input tensors to ensure consistent device usage
+        device = creep_history.device
+        
+        batch_size, max_seq_len = creep_history.size()
+        
+        # Create padding mask (1 for padding, 0 for actual values)
+        padding_mask = torch.arange(max_seq_len, device=device).unsqueeze(0) >= lengths.unsqueeze(1)
+        
+        # Embed creep values
+        creep_embedded = self.creep_embedding(creep_history.unsqueeze(-1))
+        
+        # Add time embedding if provided
+        if time_history is not None and self.time_embedding is not None:
+            time_embedded = self.time_embedding(time_history.unsqueeze(-1))
+            # Combine creep and time embeddings
+            embedded = creep_embedded + time_embedded
+        else:
+            embedded = creep_embedded
+            
+        # Add positional encoding
+        embedded = self.positional_encoding(embedded)
+        
+        # Apply dropout
+        embedded = self.dropout(embedded)
+        
+        # Process feature data
+        feature_encoded = self.feature_encoder(features)  # [batch_size, d_model]
+        
+        # Pass through encoder layers
+        encoder_output = embedded
+        for layer in self.encoder_layers:
+            encoder_output = layer(encoder_output, key_padding_mask=padding_mask)
+        
+        # Extract the last non-padding token for each sequence
+        # This will serve as our context representation for prediction
+        last_indices = (lengths - 1).clamp(min=0)  # Avoid negative indices
+        batch_indices = torch.arange(batch_size, device=device)
+        context_vectors = encoder_output[batch_indices, last_indices]  # [batch_size, d_model]
+        
+        # Combine context with features
+        combined = torch.cat([context_vectors, feature_encoded], dim=1)  # [batch_size, d_model*2]
+        integrated = self.feature_integration(combined)  # [batch_size, d_model]
+        integrated = torch.tanh(integrated)
+        
+        # Final layer normalization
+        integrated = self.layer_norm(integrated)
+        
+        # Generate predictions
+        predictions = self.predictor(integrated)  # [batch_size, target_len]
+        
+        return predictions
+
+@st.cache_resource
+def load_model_and_scalers():
+    """
+    Load the trained model and scalers
+    """
+    # Check if model and scalers exist
+    if not os.path.exists('best_llm_model-16.pt'):
+        st.error("Model file 'best_llm_model-16.pt' not found. Please run the training script first.")
+        st.stop()
+    
+    if not os.path.exists('scalers/feature_scaler.pkl'):
+        st.error("Scaler files not found. Please run the prediction script first.")
+        st.stop()
+    
+    # Load scalers
+    try:
+        with open('scalers/feature_scaler.pkl', 'rb') as f:
+            feature_scaler = pickle.load(f)
+        with open('scalers/creep_scaler.pkl', 'rb') as f:
+            creep_scaler = pickle.load(f)
+        with open('scalers/time_values.pkl', 'rb') as f:
+            time_values = pickle.load(f)
+    except Exception as e:
+        st.error(f"Error loading scalers: {e}")
+        st.stop()
+    
+    # Set device
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    # Load model
+    feature_dim = 3  # Density, fc, E
+    model = LLMConcreteModel(
+        feature_dim=feature_dim,
+        d_model=192,
+        num_layers=4,
+        num_heads=4,
+        d_ff=192 * 4,
+        dropout=0.056999223340150215,
+        target_len=1
+    )
+    
+    try:
+        model.load_state_dict(torch.load('best_llm_model-16.pt', map_location=device))
+    except Exception as e:
+        try:
+            checkpoint = torch.load('best_llm_model-16.pt', map_location=device)
+            model.load_state_dict(checkpoint, strict=False)
+            st.warning("Model loaded with non-strict loading due to architecture differences.")
+        except Exception as e2:
+            st.error(f"Error loading model: {e2}")
+            st.stop()
+    
+    model = model.to(device)
+    model.eval()
+    
+    return model, feature_scaler, creep_scaler, time_values, device
+
+def autoregressive_predict(model, features, time_values, feature_scaler, creep_scaler, device, initial_value=0):
+    """
+    Perform autoregressive prediction using the model.
+    
+    Args:
+        model: Trained PyTorch model
+        features: DataFrame with sample features
+        time_values: Array of time values
+        feature_scaler: StandardScaler for features
+        creep_scaler: Standard or custom scaler for creep values
+        device: PyTorch device
+        initial_value: Initial creep value (default: 0)
+        
+    Returns:
+        Array of predicted creep values
+    """
+    # Scale features
+    scaled_features = feature_scaler.transform(features)
+    scaled_features_tensor = torch.FloatTensor(scaled_features).to(device)
+    
+    # Initialize predictions list with the initial value
+    predictions = [initial_value]
+    # Scale the initial value 
+    scaled_predictions = [creep_scaler.transform(np.array([[initial_value]])).flatten()[0]]
+    
+    # For autoregressive prediction
+    with torch.no_grad():
+        for i in range(1, len(time_values)):
+            # Get the current history
+            history = np.array(scaled_predictions)
+            history_tensor = torch.FloatTensor(history).unsqueeze(0).to(device)  # [1, seq_len]
+            
+            # Create normalized time history if needed
+            time_history = np.log1p(time_values[:i])
+            time_tensor = torch.FloatTensor(time_history).unsqueeze(0).to(device)  # [1, seq_len]
+            
+            # Get the sequence length
+            length = torch.tensor([len(history)], device=device)
+            
+            # Generate prediction using the model with the correct interface
+            next_value = model(
+                creep_history=history_tensor,
+                features=scaled_features_tensor,
+                lengths=length,
+                time_history=time_tensor
+            ).item()
+            
+            # Store the scaled prediction
+            scaled_predictions.append(next_value)
+            
+            # Inverse transform for actual value
+            next_creep = creep_scaler.inverse_transform(np.array([[next_value]])).flatten()[0]
+            
+            # Store the actual prediction
+            predictions.append(next_creep)
+    
+    return np.array(predictions)
+
+# Load model and scalers
+model, feature_scaler, creep_scaler, time_values, device = load_model_and_scalers()
+
+# App title and description
+st.title("Concrete Creep Prediction")
+st.markdown("""
+This app predicts concrete creep strain over time using a specialized LLM-style model.
+Enter the concrete properties below to get a prediction.
+""")
+
+# Input sidebar
+st.sidebar.header("Concrete Properties")
+
+density = st.sidebar.number_input(
+    "Density (kg/m³)", 
+    min_value=2000.0, 
+    max_value=3000.0, 
+    value=2490.0,
+    step=10.0,
+    help="Concrete density in kg/m³"
+)
+
+fc = st.sidebar.number_input(
+    "Compressive Strength (fc) in MPa", 
+    min_value=10.0, 
+    max_value=1000.0, 
+    value=670.0,
+    step=10.0,
+    help="Concrete compressive strength in MPa"
+)
+
+e_modulus = st.sidebar.number_input(
+    "Elastic Modulus (E) in MPa", 
+    min_value=10000.0, 
+    max_value=1000000.0, 
+    value=436000.0,
+    step=1000.0,
+    help="Concrete elastic modulus in MPa"
+)
+
+initial_value = st.sidebar.number_input(
+    "Initial Creep Value", 
+    min_value=0.0, 
+    max_value=1000.0, 
+    value=0.0,
+    step=1.0,
+    help="Initial creep strain value (usually 0)"
+)
+
+# Time settings
+st.sidebar.header("Time Settings")
+max_days = st.sidebar.number_input(
+    "Maximum Time (days)", 
+    min_value=10, 
+    max_value=10000, 
+    value=len(time_values),
+    step=10,
+    help="Maximum time for prediction in days"
+)
+
+use_original_time = st.sidebar.checkbox(
+    "Use Original Time Values", 
+    value=True,
+    help="If checked, uses the original time values from the model training data"
+)
+
+# When the user clicks the predict button
+if st.sidebar.button("Predict Creep Strain"):
+    # Create features DataFrame
+    features_dict = {
+        'Density': density,
+        'fc': fc,
+        'E': e_modulus
+    }
+    df_features = pd.DataFrame([features_dict])
+    
+    # Adjust time values if needed
+    if use_original_time:
+        pred_time_values = time_values[:max_days] if max_days < len(time_values) else time_values
+    else:
+        pred_time_values = np.linspace(1, max_days, min(max_days, len(time_values)))
+    
+    # Run prediction
+    with st.spinner("Predicting creep strain..."):
+        predictions = autoregressive_predict(
+            model,
+            df_features,
+            pred_time_values,
+            feature_scaler,
+            creep_scaler,
+            device,
+            initial_value
+        )
+    
+    # Show results
+    st.header("Prediction Results")
+    
+    # Create columns for chart and data
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        st.subheader("Creep Strain over Time")
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.plot(pred_time_values, predictions, 'r-', linewidth=2)
+        ax.set_xlabel('Time (days)')
+        ax.set_ylabel('Creep Strain (micro-strain)')
+        ax.set_title('Predicted Concrete Creep Strain')
+        ax.grid(True)
+        st.pyplot(fig)
+    
+    with col2:
+        st.subheader("Prediction Data")
+        results_df = pd.DataFrame({
+            'Time (days)': pred_time_values,
+            'Creep Strain (micro-strain)': predictions
+        })
+        st.dataframe(results_df)
+        
+        # Download button for CSV
+        csv = results_df.to_csv(index=False)
+        st.download_button(
+            label="Download Predictions as CSV",
+            data=csv,
+            file_name="concrete_creep_predictions.csv",
+            mime="text/csv"
+        )
+        
+        # Summary statistics
+        st.subheader("Summary Statistics")
+        st.write(f"Initial Creep: {predictions[0]:.2f} micro-strain")
+        st.write(f"Final Creep: {predictions[-1]:.2f} micro-strain")
+        st.write(f"Max Creep: {np.max(predictions):.2f} micro-strain")
+        
+        # Show input parameters
+        st.subheader("Input Parameters")
+        st.write(f"Density: {density} kg/m³")
+        st.write(f"Compressive Strength (fc): {fc} MPa")
+        st.write(f"Elastic Modulus (E): {e_modulus} MPa")
+
+# Footer
+st.markdown("---")
+st.markdown("Concrete Creep Prediction App | Enhanced LLM-Style Model") 

best_llm_model-16.pt

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

docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3'
+
+services:
+  concrete-creep-app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8501:8501"
+    restart: unless-stopped
+    volumes:
+      - ./:/app
+    container_name: concrete-creep-prediction 

requirements.txt

@@ -0,0 +1,7 @@
+pandas>=1.3.0
+numpy>=1.20.0
+torch>=1.9.0
+matplotlib>=3.4.0
+scikit-learn>=0.24.0
+streamlit>=1.10.0
+seaborn>=0.11.0 

run_app.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+echo "Starting Concrete Creep Prediction App..."
+streamlit run app.py 

scalers/creep_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49eb729dbb94ff0fd794b7ae0964cc99d1784d105c9bb73e6578febbe855346f
+size 103

scalers/feature_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8451db8c4b387f2e6920ea748f3db4ce2126df9b2c7ac55049c11e74e9168a9f
+size 627

scalers/time_values.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34ef684159bebd9bebec6be8188fa46acb5f8a8893acd7fedc8d04223f5ceb4b
+size 1438