working project

.gitignore

@@ -0,0 +1,3 @@
+gcp_key.json
+__pycache__/
+*.pyc

app.py

@@ -0,0 +1,147 @@
+import streamlit as st
+import os
+from src.processing import train_mode_cloud, predict_health_cloud
+
+#st.set_page_config(page_title="Piranaware Cloud", page_icon="☁️", layout="wide")
+#st.markdown("""<style>.stApp {background-color: #F0F2F6;}</style>""", unsafe_allow_html=True)
+# --- PIRANAWARE COASTAL THEME (CSS) ---
+st.markdown("""
+    <style>
+    /* 1. Main Background - Pure black for maximum contrast */
+    .stApp {
+        background-color: #000000;
+    }
+    
+    /* 2. Text Color Fix - High visibility yellow */
+    .stApp, .stMarkdown, p, label {
+        color: #FFD700 !important; /* Bright safety yellow */
+    }
+    
+    /* 3. Headers - Strong yellow, slightly warmer */
+    h1, h2, h3, h4, h5, h6 {
+        color: #FFEB3B !important; /* Vivid header yellow */
+        font-family: 'Helvetica Neue', sans-serif;
+        font-weight: 700;
+    }
+    
+    /* 4. Tab Styling */
+    button[data-baseweb="tab"] {
+        color: #BDB76B !important; /* Muted yellow for inactive */
+        font-weight: 600;
+    }
+    button[data-baseweb="tab"][aria-selected="true"] {
+        color: #FFD700 !important;
+        border-bottom: 4px solid #FFD700 !important;
+        background-color: #111111 !important;
+    }
+
+    /* 5. Buttons - Black & yellow safety style */
+    div.stButton > button {
+        background-color: #000000;
+        color: #FFD700;
+        border: 3px solid #FFD700;
+        border-radius: 8px;
+        font-weight: bold;
+    }
+    div.stButton > button:hover {
+        background-color: #FFD700;
+        color: #000000;
+        box-shadow: 0 4px 14px rgba(255, 215, 0, 0.6);
+        border: 3px solid #FFD700;
+    }
+
+    /* 6. Input Labels */
+    .stAudioInput label, .stFileUploader label, .stSelectbox label, .stTextInput label {
+        color: #FFD700 !important;
+        font-weight: 700;
+    }
+    
+    /* 7. Results Box Styling */
+    .result-box-healthy {
+        background-color: #111111;
+        border: 2px solid #00FF9C;
+        border-left: 6px solid #00C781;
+        padding: 15px; border-radius: 5px;
+        color: #00FF9C;
+    }
+    .result-box-anomaly {
+        background-color: #111111;
+        border: 2px solid #FF5252;
+        border-left: 6px solid #D32F2F;
+        padding: 15px; border-radius: 5px;
+        color: #FF5252;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+
+TEMP_AUDIO_DIR = "temp_audio_uploads"
+os.makedirs(TEMP_AUDIO_DIR, exist_ok=True)
+
+def save_audio(audio_value):
+    if audio_value is None: return None
+    audio_value.seek(0)
+    save_path = os.path.join(TEMP_AUDIO_DIR, "input.wav")
+    with open(save_path, "wb") as f:
+        f.write(audio_value.read())
+    return save_path
+
+# --- LOGIN ---
+with st.sidebar:
+    #st.image("https://img.icons8.com/color/96/speedboat.png", width=80)
+    st.title("User Login")
+    st.markdown("### Ensure to use your exact boat ID")
+    
+    # BOAT ID INPUT
+    boat_id = st.text_input("Enter Boat ID", value="DEMO_BOAT_01").upper().replace(" ", "_")
+    st.caption("Training saved online on Google Cloud.")
+    st.divider()
+    st.info(f"Active Session:\n**{boat_id}**")
+
+# --- MAIN APP ---
+st.title("Piranaware Boat Engine AI")
+
+tab_train, tab_test = st.tabs(["🛠️ Train Baseline", "🩺 Diagnostics"])
+
+with tab_train:
+    st.info(f"Training models for: **{boat_id}**. Ensure engine is HEALTHY.")
+    c1, c2, c3 = st.columns(3)
+    
+    for col, mode in [(c1, "idle"), (c2, "slow"), (c3, "fast")]:
+        with col:
+            st.markdown(f"### {mode.upper()}")
+            try: audio = st.audio_input(f"Rec {mode}", key=f"rec_{mode}")
+            except: audio = st.file_uploader(f"Up {mode}", type=['wav'], key=f"rec_{mode}")
+            
+            if st.button(f"Train {mode.upper()}", key=f"btn_{mode}"):
+                if audio:
+                    path = save_audio(audio)
+                    with st.spinner("Training & Uploading to Cloud..."):
+                        res = train_mode_cloud(path, mode, boat_id)
+                    st.success(res)
+                else:
+                    st.error("No Audio")
+
+with tab_test:
+    st.divider()
+    st.markdown(f"### Diagnostics for: **{boat_id}**")
+    
+    col_in, col_out = st.columns([1, 2])
+    with col_in:
+        mode = st.selectbox("Select Mode", ["idle", "slow", "fast"])
+        try: test_audio = st.audio_input("Record", key="test")
+        except: test_audio = st.file_uploader("Upload", type=['wav'], key="test")
+        btn = st.button("Run Diagnostics")
+        
+    with col_out:
+        if btn and test_audio:
+            path = save_audio(test_audio)
+            with st.spinner("Downloading Model & Analyzing..."):
+                report = predict_health_cloud(path, mode, boat_id)
+            
+            if "HEALTHY" in report:
+                st.success(report)
+            elif "ANOMALY" in report:
+                st.error(report)
+            else:
+                st.warning(report)

requirements.txt

@@ -0,0 +1,8 @@
+tensorflow
+librosa
+numpy> 2.0
+matplotlib
+scikit-learn
+streamlit 
+google-cloud-storage
+huggingface-hub

src/model.py

@@ -0,0 +1,22 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models
+
+def build_autoencoder(input_shape):
+    input_img = layers.Input(shape=input_shape)
+    
+    # Encoder
+    x = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
+    x = layers.MaxPooling2D((2, 2), padding='same')(x)
+    x = layers.Conv2D(16, (3, 3), activation='relu', padding='same')(x)
+    encoded = layers.MaxPooling2D((2, 2), padding='same')(x)
+
+    # Decoder
+    x = layers.Conv2D(16, (3, 3), activation='relu', padding='same')(encoded)
+    x = layers.UpSampling2D((2, 2))(x)
+    x = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(x)
+    x = layers.UpSampling2D((2, 2))(x)
+    decoded = layers.Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)
+
+    autoencoder = models.Model(input_img, decoded)
+    autoencoder.compile(optimizer='adam', loss='mse')
+    return autoencoder

src/preprocess.py

@@ -0,0 +1,26 @@
+import librosa
+import numpy as np
+
+SAMPLE_RATE = 22050  
+DURATION = 1.0       
+SAMPLES_PER_SLICE = int(SAMPLE_RATE * DURATION)
+N_MELS = 128         
+
+def audio_to_spectrograms(file_path):
+    try:
+        y, sr = librosa.load(file_path, sr=SAMPLE_RATE)
+        num_slices = len(y) // SAMPLES_PER_SLICE
+        if num_slices < 1: return None
+
+        spectrograms = []
+        for i in range(num_slices):
+            y_slice = y[i*SAMPLES_PER_SLICE : (i+1)*SAMPLES_PER_SLICE]
+            spec = librosa.feature.melspectrogram(y=y_slice, sr=sr, n_mels=N_MELS)
+            log_spec = librosa.power_to_db(spec, ref=np.max)
+            norm_spec = np.clip((log_spec + 80) / 80, 0, 1)
+            spectrograms.append(norm_spec[..., np.newaxis])
+            
+        return np.array(spectrograms)
+    except Exception as e:
+        print(f"Error: {e}")
+        return None

src/processing.py

@@ -0,0 +1,95 @@
+import numpy as np
+import os
+import json
+import tensorflow as tf
+from src.preprocess import audio_to_spectrograms
+from src.model import build_autoencoder
+from src.storage import upload_file, download_file
+
+TEMP_DIR = "temp_models"
+if not os.path.exists(TEMP_DIR):
+    os.makedirs(TEMP_DIR)
+
+def train_mode_cloud(audio_path, mode_name, boat_id):
+    # 1. Preprocess
+    X_train = audio_to_spectrograms(audio_path)
+    if X_train is None: return "❌ Audio too short (min 1 sec)."
+
+    # 2. Train
+    autoencoder = build_autoencoder(X_train.shape[1:])
+    autoencoder.fit(X_train, X_train, epochs=40, batch_size=4, verbose=0)
+
+    # 3. Calculate Threshold (THE FIX)
+    reconstructions = autoencoder.predict(X_train)
+    mse = np.mean(np.power(X_train - reconstructions, 2), axis=(1, 2, 3))
+    
+   
+    threshold = float(np.mean(mse) + (2 * np.std(mse)))
+
+    # 4. Save Locally
+    model_filename = f"{mode_name}_model.h5"
+    meta_filename = f"{mode_name}_meta.json"
+    local_model_path = os.path.join(TEMP_DIR, model_filename)
+    local_meta_path = os.path.join(TEMP_DIR, meta_filename)
+
+    autoencoder.save(local_model_path, save_format='h5', include_optimizer=False)
+    with open(local_meta_path, 'w') as f:
+        json.dump({"threshold": threshold}, f)
+
+    # 5. Upload
+    u1 = upload_file(local_model_path, boat_id, model_filename)
+    u2 = upload_file(local_meta_path, boat_id, meta_filename)
+
+    if u1 and u2:
+        return f"✅ Calibrated {mode_name.upper()} | Threshold: {threshold:.5f}"
+    else:
+        return "⚠️ Trained locally, but Cloud Upload Failed."
+
+def predict_health_cloud(audio_path, mode_name, boat_id):
+    model_filename = f"{mode_name}_model.h5"
+    meta_filename = f"{mode_name}_meta.json"
+    local_model_path = os.path.join(TEMP_DIR, model_filename)
+    local_meta_path = os.path.join(TEMP_DIR, meta_filename)
+
+    # 1. Download
+    d1 = download_file(boat_id, model_filename, local_model_path)
+    d2 = download_file(boat_id, meta_filename, local_meta_path)
+
+    if not (d1 and d2):
+        return f"⚠️ No trained model found in cloud for Boat: {boat_id} (Mode: {mode_name})"
+
+    # 2. Load
+    with open(local_meta_path, 'r') as f:
+        threshold = json.load(f)["threshold"]
+    
+    model = tf.keras.models.load_model(local_model_path, compile=False)
+
+    # 3. Predict
+    X_test = audio_to_spectrograms(audio_path)
+    if X_test is None: return "Error: Audio too short."
+    
+    reconstructions = model.predict(X_test)
+    # Calculate error for each second of audio
+    mse = np.mean(np.power(X_test - reconstructions, 2), axis=(1, 2, 3))
+    
+    # 4. Analysis
+    anomalies = np.sum(mse > threshold)
+    health_score = 100 * (1 - (anomalies / len(mse)))
+    
+    # 5. Debug Data (Shows you WHY it decided what it decided)
+    avg_error = np.mean(mse)
+    max_error = np.max(mse)
+    
+    status = "🟢 HEALTHY" if health_score > 85 else "🔴 ANOMALY DETECTED"
+    
+    # Return detailed report
+    return f"""
+    STATUS: {status}
+    Confidence Score: {health_score:.1f}%
+    
+    --- TECHNICAL TELEMETRY ---
+    Threshold Limit : {threshold:.5f}
+    Your Avg Error  : {avg_error:.5f}
+    Your Max Error  : {max_error:.5f}
+    Anomalous Secs  : {anomalies} / {len(mse)}
+    """

src/storage.py

@@ -0,0 +1,58 @@
+import os
+import json
+import streamlit as st
+from google.cloud import storage
+from google.oauth2 import service_account
+
+# ✅ UPDATED WITH YOUR BUCKET NAME
+BUCKET_NAME = "piranaware20251227841ph"
+
+def get_storage_client():
+    """
+    Authenticates with Google Cloud.
+    CHECKS LOCAL FILE FIRST (to prevent crashes in Codespaces),
+    then checks Secrets (for Hugging Face).
+    """
+    # 1. Local Dev: Check for local file FIRST
+    if os.path.exists("gcp_key.json"):
+        return storage.Client.from_service_account_json("gcp_key.json")
+
+    # 2. Production: Check Streamlit Secrets
+    try:
+        if "gcp_service_account" in st.secrets:
+            creds_dict = dict(st.secrets["gcp_service_account"])
+            creds = service_account.Credentials.from_service_account_info(creds_dict)
+            return storage.Client(credentials=creds)
+    except Exception:
+        # If secrets don't exist, we just move on
+        pass
+    
+    # 3. If neither works
+    st.error("⚠️ No Google Cloud credentials found. Cannot save models.")
+    return None
+
+def upload_file(local_path, boat_id, filename):
+    client = get_storage_client()
+    if not client: return False
+
+    bucket = client.bucket(BUCKET_NAME)
+    # Creates folder structure: boat_id/filename
+    blob_name = f"{boat_id}/{filename}"
+    blob = bucket.blob(blob_name)
+    
+    blob.upload_from_filename(local_path)
+    return True
+
+def download_file(boat_id, filename, local_dest):
+    client = get_storage_client()
+    if not client: return False
+
+    bucket = client.bucket(BUCKET_NAME)
+    blob_name = f"{boat_id}/{filename}"
+    blob = bucket.blob(blob_name)
+    
+    if not blob.exists():
+        return False
+        
+    blob.download_to_filename(local_dest)
+    return True