Upload 3 files

README.md

@@ -0,0 +1,53 @@
+---
+title: SONAR-AI
+emoji: 🔬
+colorFrom: red
+colorTo: blue
+sdk: streamlit
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🔬 SONAR-AI
+
+**نظام التحليل الذكي للأشعة السينية | Smart X-Ray Analysis System**
+
+## Author
+**Dr. Abbas Fadhil Jasim Mohammed AL-Gburi**
+- Iraqi General Customs Authority
+- Universiti Kebangsaan Malaysia (UKM)
+
+## About
+This system uses **Deep-DSOS** (Deep Dynamic Symbiotic Organisms Search) algorithm for intelligent X-ray image analysis and prohibited item detection.
+
+## Features
+- 🔫 Gun Detection
+- 🔪 Knife Detection
+- ✂️ Scissors Detection
+- 🔧 Tools Detection
+- ✅ Safe Item Classification
+
+## Algorithm
+Deep-DSOS is based on symbiotic relationships in nature:
+- **Mutualism**: Both organisms benefit
+- **Commensalism**: One benefits, other unaffected
+- **Parasitism**: One benefits at expense of other
+
+Enhanced with: Singer Map + Lévy Flight + Simulated Annealing
+
+## Usage
+1. Click "Train Model" to train the classifier
+2. Upload an X-ray image
+3. Click "Analyze" to get results
+
+## Citation
+```bibtex
+@phdthesis{algburi2025,
+  author = {AL-Gburi, Abbas Fadhil Jasim},
+  title = {Hybridized Symbiotic Organisms Search with Simulated Annealing},
+  school = {Universiti Kebangsaan Malaysia},
+  year = {2025}
+}
+```

app.py

@@ -0,0 +1,326 @@
+"""
+SONAR-AI - Smart X-Ray Analysis System
+نظام التحليل الذكي للأشعة السينية
+
+Dr. Abbas Fadhil Jasim AL-Gburi
+Iraqi General Customs Authority & UKM
+"""
+
+import streamlit as st
+import numpy as np
+from PIL import Image
+import time
+
+# Page config
+st.set_page_config(
+    page_title="SONAR-AI",
+    page_icon="🔬",
+    layout="wide"
+)
+
+# Classes
+CLASSES = {
+    0: ("Gun", "سلاح ناري 🔫"),
+    1: ("Knife", "سكين 🔪"),
+    2: ("Wrench", "مفتاح ربط 🔧"),
+    3: ("Pliers", "كماشة 🔧"),
+    4: ("Scissors", "مقص ✂️"),
+    5: ("Hammer", "مطرقة 🔨"),
+    6: ("Safe", "آمن ✅")
+}
+
+# Singer Map
+class SingerMap:
+    def __init__(self, mu=1.07, x0=0.7):
+        self.mu, self.x = mu, x0
+    
+    def next(self):
+        x = self.x
+        self.x = self.mu * (7.86*x - 23.31*x**2 + 28.75*x**3 - 13.30*x**4)
+        self.x = max(0.001, min(0.999, abs(self.x)))
+        return self.x
+
+# Feature Extractor
+class FeatureExtractor:
+    def __init__(self, n_features=256):
+        self.n_features = n_features
+    
+    def extract(self, image):
+        if len(image.shape) == 2:
+            image = np.stack([image]*3, axis=-1)
+        
+        h, w = image.shape[:2]
+        features = []
+        
+        for c in range(3):
+            hist, _ = np.histogram(image[:,:,c], bins=16, range=(0,255))
+            features.extend(hist / (hist.sum() + 1e-6))
+        
+        gray = np.mean(image, axis=2)
+        gh, gw = h//4, w//4
+        for i in range(4):
+            for j in range(4):
+                patch = gray[i*gh:(i+1)*gh, j*gw:(j+1)*gw]
+                features.extend([np.mean(patch), np.std(patch)])
+        
+        dark_ratio = np.sum(gray < 60) / gray.size
+        very_dark = np.sum(gray < 30) / gray.size
+        features.extend([dark_ratio, very_dark, np.mean(gray), np.std(gray)])
+        
+        edges_h = np.abs(np.diff(gray, axis=0)).mean()
+        edges_v = np.abs(np.diff(gray, axis=1)).mean()
+        features.extend([edges_h, edges_v])
+        
+        features = np.array(features)
+        if len(features) < self.n_features:
+            features = np.pad(features, (0, self.n_features - len(features)))
+        return features[:self.n_features]
+
+# Deep-DSOS
+class DeepDSOS:
+    def __init__(self, eco_size=20, max_iter=30, alpha=0.6):
+        self.eco_size = eco_size
+        self.max_iter = max_iter
+        self.alpha = alpha
+        self.singer = SingerMap()
+    
+    def fitness(self, solution, X, y):
+        selected = np.where(solution == 1)[0]
+        if len(selected) == 0:
+            return 0.0
+        
+        X_sel = X[:, selected]
+        
+        from sklearn.neighbors import KNeighborsClassifier
+        from sklearn.model_selection import cross_val_score
+        try:
+            knn = KNeighborsClassifier(n_neighbors=3)
+            scores = cross_val_score(knn, X_sel, y, cv=3)
+            perf = scores.mean()
+        except:
+            perf = 0.5
+        
+        reduction = 1 - len(selected) / len(solution)
+        return self.alpha * perf + (1 - self.alpha) * reduction
+    
+    def optimize(self, X, y, progress_bar=None):
+        n_features = X.shape[1]
+        
+        ecosystem = np.random.randint(0, 2, (self.eco_size, n_features))
+        for i in range(self.eco_size):
+            if np.sum(ecosystem[i]) == 0:
+                ecosystem[i, np.random.randint(n_features)] = 1
+        
+        fitness_values = np.array([self.fitness(org, X, y) for org in ecosystem])
+        best_idx = np.argmax(fitness_values)
+        best = ecosystem[best_idx].copy()
+        best_fitness = fitness_values[best_idx]
+        
+        for iteration in range(self.max_iter):
+            if progress_bar:
+                progress_bar.progress((iteration + 1) / self.max_iter)
+            
+            chaos = self.singer.next()
+            
+            for i in range(self.eco_size):
+                j = np.random.choice([x for x in range(self.eco_size) if x != i])
+                
+                Xi = ecosystem[i].astype(float)
+                Xbest = best.astype(float)
+                
+                Xi_new = Xi + np.random.random(n_features) * chaos * (Xbest - Xi)
+                sigmoid = 1 / (1 + np.exp(-np.clip(Xi_new, -500, 500)))
+                Xi_new = (sigmoid > 0.5).astype(int)
+                if np.sum(Xi_new) == 0:
+                    Xi_new[np.argmax(sigmoid)] = 1
+                
+                if self.fitness(Xi_new, X, y) > fitness_values[i]:
+                    ecosystem[i] = Xi_new
+                    fitness_values[i] = self.fitness(Xi_new, X, y)
+            
+            current_best = np.argmax(fitness_values)
+            if fitness_values[current_best] > best_fitness:
+                best = ecosystem[current_best].copy()
+                best_fitness = fitness_values[current_best]
+        
+        return best, best_fitness
+
+# SONAR-AI Model
+class SonarAI:
+    def __init__(self):
+        self.extractor = FeatureExtractor(256)
+        self.classifier = None
+        self.selected_features = None
+        self.is_trained = False
+    
+    def generate_data(self, n_samples=300):
+        np.random.seed(42)
+        h, w = 224, 224
+        images, labels = [], []
+        
+        samples_per_class = n_samples // 7
+        
+        for class_id in range(6):
+            for _ in range(samples_per_class):
+                img = np.random.randint(80, 160, (h, w, 3), dtype=np.uint8)
+                x, y = np.random.randint(40, w-100), np.random.randint(40, h-80)
+                obj_h, obj_w = np.random.randint(30, 60), np.random.randint(50, 100)
+                img[y:y+obj_h, x:x+obj_w] = np.random.randint(5, 40, (obj_h, obj_w, 3), dtype=np.uint8)
+                images.append(img)
+                labels.append(class_id)
+        
+        for _ in range(n_samples - len(images)):
+            img = np.random.randint(90, 170, (h, w, 3), dtype=np.uint8)
+            for _ in range(np.random.randint(2, 5)):
+                rx, ry = np.random.randint(10, w-60), np.random.randint(10, h-50)
+                rw, rh = np.random.randint(30, 70), np.random.randint(25, 50)
+                color = np.random.randint(100, 160)
+                img[ry:ry+rh, rx:rx+rw] = np.random.randint(color-20, color+20, (rh, rw, 3), dtype=np.uint8)
+            images.append(img)
+            labels.append(6)
+        
+        indices = np.random.permutation(len(images))
+        return [images[i] for i in indices], [labels[i] for i in indices]
+    
+    def train(self, progress_bar=None, status_text=None):
+        if status_text:
+            status_text.text("توليد البيانات...")
+        images, labels = self.generate_data()
+        
+        if status_text:
+            status_text.text("استخلاص الميزات...")
+        X = np.array([self.extractor.extract(img) for img in images])
+        y = np.array(labels)
+        
+        if status_text:
+            status_text.text("تشغيل Deep-DSOS...")
+        dsos = DeepDSOS(eco_size=15, max_iter=20, alpha=0.6)
+        solution, fitness = dsos.optimize(X, y, progress_bar)
+        
+        self.selected_features = np.where(solution == 1)[0]
+        if len(self.selected_features) == 0:
+            self.selected_features = np.arange(min(50, X.shape[1]))
+        
+        X_selected = X[:, self.selected_features]
+        
+        if status_text:
+            status_text.text("تدريب المصنف...")
+        from sklearn.svm import SVC
+        from sklearn.model_selection import cross_val_score
+        
+        self.classifier = SVC(kernel='rbf', C=10, gamma='scale',
+                             class_weight='balanced', probability=True, random_state=42)
+        
+        scores = cross_val_score(self.classifier, X_selected, y, cv=3)
+        accuracy = scores.mean()
+        
+        self.classifier.fit(X_selected, y)
+        self.is_trained = True
+        
+        return {
+            'accuracy': accuracy,
+            'features': f"{len(self.selected_features)}/{X.shape[1]}",
+            'reduction': f"{(1 - len(self.selected_features)/X.shape[1])*100:.1f}%",
+            'samples': len(images)
+        }
+    
+    def analyze(self, image):
+        if not self.is_trained:
+            return None, None, None
+        
+        img = Image.fromarray(image).resize((224, 224))
+        img_array = np.array(img)
+        
+        features = self.extractor.extract(img_array)
+        features_selected = features[self.selected_features]
+        
+        prediction = self.classifier.predict([features_selected])[0]
+        probabilities = self.classifier.predict_proba([features_selected])[0]
+        confidence = float(np.max(probabilities))
+        
+        return prediction, confidence, probabilities
+
+# Initialize model
+if 'model' not in st.session_state:
+    st.session_state.model = SonarAI()
+
+# UI
+st.markdown("""
+<h1 style='text-align: center; color: #e94560;'>🔬 SONAR-AI</h1>
+<p style='text-align: center; color: #666;'>نظام التحليل الذكي للأشعة السينية | Smart X-Ray Analysis System</p>
+<p style='text-align: center; color: #888; font-size: 0.9em;'>د. عباس فاضل جاسم محمد الجبوري | الهيئة العامة للكمارك - العراق</p>
+<hr>
+""", unsafe_allow_html=True)
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown("### ⚙️ تدريب النموذج")
+    
+    if st.session_state.model.is_trained:
+        st.success("✅ النموذج جاهز!")
+    else:
+        st.warning("⚠️ النموذج غير مدرب")
+    
+    if st.button("🚀 تدريب النموذج", type="primary", use_container_width=True):
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        with st.spinner("جاري التدريب..."):
+            results = st.session_state.model.train(progress_bar, status_text)
+        
+        status_text.empty()
+        progress_bar.empty()
+        
+        st.success("✅ تم الت��ريب بنجاح!")
+        st.metric("الدقة", f"{results['accuracy']*100:.1f}%")
+        st.metric("الميزات", results['features'])
+        st.metric("التقليل", results['reduction'])
+        st.rerun()
+    
+    st.markdown("---")
+    st.markdown("""
+    ### 📚 عن الخوارزمية
+    **Deep-DSOS** - خوارزمية الكائنات التكافلية الديناميكية العميقة
+    
+    تحسينات: Singer Map + Lévy Flight + SA
+    """)
+
+with col2:
+    st.markdown("### 📤 تحليل الصورة")
+    
+    uploaded_file = st.file_uploader("ارفع صورة X-Ray", type=['png', 'jpg', 'jpeg'])
+    
+    if uploaded_file is not None:
+        image = Image.open(uploaded_file).convert('RGB')
+        st.image(image, caption="الصورة المرفوعة", use_container_width=True)
+        
+        if st.button("🔍 تحليل الصورة", type="secondary", use_container_width=True):
+            if not st.session_state.model.is_trained:
+                st.error("❌ الرجاء تدريب النموذج أولاً!")
+            else:
+                with st.spinner("جاري التحليل..."):
+                    image_array = np.array(image)
+                    prediction, confidence, probabilities = st.session_state.model.analyze(image_array)
+                
+                class_en, class_ar = CLASSES[prediction]
+                is_prohibited = prediction != 6
+                
+                if is_prohibited:
+                    st.error(f"## ⚠️ تحذير: {class_ar}")
+                else:
+                    st.success(f"## ✅ {class_ar}")
+                
+                st.metric("نسبة الثقة", f"{confidence*100:.1f}%")
+                
+                st.markdown("#### جميع الاحتمالات:")
+                for i, prob in enumerate(probabilities):
+                    en, ar = CLASSES[i]
+                    st.progress(prob, text=f"{ar} ({en}): {prob*100:.1f}%")
+
+st.markdown("---")
+st.markdown("""
+<p style='text-align: center; color: #888;'>
+© 2026 SONAR-AI | Dr. Abbas AL-Gburi | Iraqi General Customs Authority & UKM
+</p>
+""", unsafe_allow_html=True)

requirements.txt

@@ -0,0 +1,4 @@
+streamlit
+numpy
+scikit-learn
+pillow