Upload 3 files

app.py

@@ -2,632 +2,189 @@ import streamlit as st
 import tensorflow as tf
 import numpy as np
 import cv2
-import pywt  # Thư viện xử lý wavelet
 from PIL import Image
-from tensorflow.keras import layers, models
-from tensorflow.keras.applications import EfficientNetB0
-from tensorflow.keras.applications.efficientnet import preprocess_input
-import joblib
 import io
-import os
-import cv2
-import numpy as np
-from tensorflow import keras
-from tensorflow.keras import layers, models
-from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
-from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
-import matplotlib.pyplot as plt
-import random
-from keras.applications import ResNet50
-from tensorflow.keras.applications.resnet import preprocess_input
-from tensorflow.keras import layers, models
-from tensorflow.keras.applications.resnet import preprocess_input
-from tensorflow.keras.applications import EfficientNetB0
-from tensorflow.keras.applications.efficientnet import preprocess_input
-from tensorflow.keras.layers import Lambda  # Đảm bảo nhập Lambda từ tensorflow.keras.layers
-from skimage.feature import graycomatrix, graycoprops
-from keras.applications import ResNet50
-from tensorflow.keras.applications.resnet import preprocess_input
 
-# Add Cloudinary import
-import cloudinary
-import cloudinary.uploader
-from cloudinary.utils import cloudinary_url
-
-# Cloudinary Configuration
-cloudinary.config(
-    cloud_name = os.getenv("CLOUD"),
-    api_key = os.getenv("API"),
-    api_secret = os.getenv("SECRET"),
-    secure=True
+# Set page config
+st.set_page_config(
+    page_title="Stone Classification",
+    page_icon="🪨",
+    layout="wide"
 )
 
-def upload_to_cloudinary(file_path, label):
-    """
-    Upload file to Cloudinary with specified label as folder
-    """
-    try:
-        # Upload to Cloudinary
-        upload_result = cloudinary.uploader.upload(
-            file_path,
-            folder=label,
-            public_id=f"{label}_{os.path.basename(file_path)}"
-        )
-
-        # Generate optimized URLs
-        optimize_url, _ = cloudinary_url(
-            upload_result['public_id'],
-            fetch_format="auto",
-            quality="auto"
-        )
-
-        auto_crop_url, _ = cloudinary_url(
-            upload_result['public_id'],
-            width=500,
-            height=500,
-            crop="auto",
-            gravity="auto"
-        )
-
-        return {
-            "upload_result": upload_result,
-            "optimize_url": optimize_url,
-            "auto_crop_url": auto_crop_url
-        }
-
-    except Exception as e:
-        return f"Error uploading to Cloudinary: {str(e)}"
+# Custom CSS to improve the appearance
+st.markdown("""
+    <style>
+    .main {
+        padding: 2rem;
+    }
+    .stButton>button {
+        width: 100%;
+        margin-top: 1rem;
+    }
+    .upload-text {
+        text-align: center;
+        padding: 2rem;
+    }
+    .prediction-card {
+        padding: 2rem;
+        border-radius: 0.5rem;
+        background-color: #f0f2f6;
+        margin: 1rem 0;
+    }
+    .top-predictions {
+        margin-top: 2rem;
+        padding: 1rem;
+        background-color: white;
+        border-radius: 0.5rem;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.12);
+    }
+    .prediction-bar {
+        display: flex;
+        align-items: center;
+        margin: 0.5rem 0;
+    }
+    .prediction-label {
+        width: 100px;
+        font-weight: 500;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+@st.cache_resource
+def load_model():
+    """Load the trained model"""
+    return tf.keras.models.load_model('custom_model.h5')
+
+def preprocess_image(image):
+    """Preprocess the uploaded image"""
+    # # Convert to RGB if needed
+    # if image.mode != 'RGB':
+    #     image = image.convert('RGB')
+    
+    # Convert to numpy array
+    img_array = np.array(image)
+    
+    # # Convert to RGB if needed
+    # if len(img_array.shape) == 2:  # Grayscale
+    #     img_array = cv2.cvtColor(img_array, cv2.COLOR_GRAY2RGB)
+    # elif img_array.shape[2] == 4:  # RGBA
+    #     img_array = cv2.cvtColor(img_array, cv2.COLOR_RGBA2RGB)
+    
+    # # Preprocess image similar to training
+    # img_hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV)
+    # img_hsv[:, :, 2] = cv2.equalizeHist(img_hsv[:, :, 2])
+    # img_array = cv2.cvtColor(img_hsv, cv2.COLOR_HSV2RGB)
+    
+    # # Adjust brightness
+    # target_brightness = 150
+    # current_brightness = np.mean(img_array)
+    # alpha = target_brightness / (current_brightness + 1e-5)
+    # img_array = cv2.convertScaleAbs(img_array, alpha=alpha, beta=0)
+    
+    # # Apply Gaussian blur
+    # img_array = cv2.GaussianBlur(img_array, (5, 5), 0)
+    
+    # Resize
+    img_array = cv2.resize(img_array, (256, 256))
+    
+    # Normalize
+    img_array = img_array.astype('float32') / 255.0
+    
+    return img_array
+
+def get_top_predictions(prediction, class_names, top_k=5):
+    """Get top k predictions with their probabilities"""
+    # Get indices of top k predictions
+    top_indices = prediction.argsort()[0][-top_k:][::-1]
+    
+    # Get corresponding class names and probabilities
+    top_predictions = [
+        (class_names[i], float(prediction[0][i]) * 100)
+        for i in top_indices
+    ]
+    
+    return top_predictions
 
 def main():
-    st.title("Web App Phân loại đá")
-    st.write("Tải lên hình ảnh của một viên đá để phân loại loại của nó.")
-
-    # Load model and scaler
-    model, scaler = load_model_and_scaler()
-    if model is None or scaler is None:
-        st.error("Không thể tải mô hình hoặc bộ chuẩn hóa. Vui lòng đảm bảo rằng cả hai tệp đều tồn tại.")
-        return
-
-    # Initialize session state
+    # Title
+    st.title("🪨 Stone Classification")
+    st.write("Upload an image of a stone to classify its type")
+    
+    # Initialize session state for prediction if not exists
     if 'predictions' not in st.session_state:
         st.session_state.predictions = None
-    if 'uploaded_image' not in st.session_state:
-        st.session_state.uploaded_image = None
-
+    
+    # Create two columns
     col1, col2 = st.columns(2)
-
+    
     with col1:
-        st.subheader("Tải lên Hình ảnh")
-        uploaded_file = st.file_uploader("Chọn hình ảnh...", type=["jpg", "jpeg", "png"])
-
+        st.subheader("Upload Image")
+        uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+        
         if uploaded_file is not None:
-            try:
-                image = Image.open(uploaded_file)
-                st.image(image, caption="Hình ảnh đã tải lên", use_column_width=True)
-                st.session_state.uploaded_image = image
-
-                with st.spinner('Đang phân tích hình ảnh...'):
-                    processed_image = preprocess_image(image, scaler)
-                    prediction = model.predict(processed_image)
-
+            # Display uploaded image
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image", use_column_width=True)
+
+            with st.spinner('Analyzing image...'):
+                try:
+                    # Load model
+                    model = load_model()
+                    
+                    # Preprocess image
+                    processed_image = preprocess_image(image)
+                    
+                    # Make prediction
+                    prediction = model.predict(np.expand_dims(processed_image, axis=0))
                     class_names = ['10', '6.5', '7', '7.5', '8', '8.5', '9', '9.2', '9.5', '9.7']
-                    st.session_state.predictions = get_top_predictions(prediction, class_names)
-
-            except Exception as e:
-                st.error(f"Lỗi khi xử lý hình ảnh: {str(e)}")
-
+                    
+                    # Get top 5 predictions
+                    top_predictions = get_top_predictions(prediction, class_names)
+                    
+                    # Store in session state
+                    st.session_state.predictions = top_predictions
+                    
+                except Exception as e:
+                    st.error(f"Error during prediction: {str(e)}")
+    
     with col2:
-        st.subheader("Kết quả Dự đoán")
-        if st.session_state.predictions:
-            # Display main prediction
-            top_class, top_confidence = st.session_state.predictions[0]
-            st.markdown(
-                f"""
-                <div class='prediction-card'>
-                    <h3>Dự đoán chính: Màu {top_class}</h3>
-                    <h3>Độ tin cậy: {top_confidence:.2f}%</h3>
-                </div>
-                """,
-                unsafe_allow_html=True
-            )
-
-            # Display confidence bar
-            st.progress(float(top_confidence) / 100)
-
-            # Display top 5 predictions
-            st.markdown("### 5 Dự đoán hàng đầu")
-            st.markdown("<div class='top-predictions'>", unsafe_allow_html=True)
-
-            for class_name, confidence in st.session_state.predictions:
-                st.markdown(
-                    f"**Màu {class_name}: Độ tin cậy {confidence:.2f}%**"
-                )
-                st.progress(float(confidence) / 100)
-
-            st.markdown("</div>", unsafe_allow_html=True)
-
-            # User Confirmation Section
-            st.markdown("### Xác nhận độ chính xác của mô hình")
-            st.write("Giúp chúng tôi cải thiện mô hình bằng cách xác nhận độ chính xác của dự đoán.")
-
-            # Accuracy Radio Button
-            accuracy_option = st.radio(
-                "Dự đoán có chính xác không?",
-                ["Chọn", "Chính xác", "Không chính xác"],
-                index=0
-            )
-
-            if accuracy_option == "Không chính xác":
-                # Input for correct grade
-                correct_grade = st.selectbox(
-                    "Chọn màu đá đúng:",
-                    ['10', '6.5', '7', '7.5', '8', '8.5', '9', '9.2', '9.5', '9.7'],
-                    index=None,
-                    placeholder="Chọn màu đúng"
-                )
-
-                # Upload button
-                if st.button("Tải lên Hình ảnh để sửa chữa"):
-                    if correct_grade and st.session_state.uploaded_image:
-                        try:
-                            # Đọc tệp từ `st.session_state.uploaded_image`
-                            uploaded_file = st.session_state.uploaded_image
-                            
-                            # Kiểm tra nếu uploaded_file đã là PIL Image
-                            if isinstance(uploaded_file, Image.Image):
-                                resized_image = uploaded_file.resize((512, 512))
-                            else:
-                                # Nếu là file-like object, mở bằng Pillow
-                                uploaded_image = Image.open(uploaded_file)
-                                resized_image = uploaded_image.resize((512, 512))
-                            
-                            # Lưu tệp ảnh resize tạm thời
-                            temp_image_path = f"temp_image_{hash(uploaded_file.name) if hasattr(uploaded_file, 'name') else 'unknown'}.png"
-                            resized_image.save(temp_image_path)
-                            
-                            # Tải ảnh lên Cloudinary
-                            cloudinary_result = upload_to_cloudinary(temp_image_path, correct_grade)
-                            
-                            if isinstance(cloudinary_result, dict):
-                                st.success(f"Hình ảnh đã được tải lên thành công cho màu {correct_grade}")
-                                st.write(f"URL công khai: {cloudinary_result['upload_result']['secure_url']}")
-                            else:
-                                st.error(cloudinary_result)
-                            
-                            # Xóa tệp tạm
-                            os.remove(temp_image_path)
-                        
-                        except Exception as e:
-                            st.error(f"Tải lên thất bại: {str(e)}")
-                    else:
-                        st.warning("Vui lòng chọn màu đúng trước khi tải lên.")
-                else:
-                    st.info("Tải lên hình ảnh để xem các dự đoán.")
-
+        st.subheader("Prediction Results")
+        if st.session_state.predictions is not None:
+            # Create a card-like container for results
+            results_container = st.container()
+            with results_container:
+                # Display main prediction
+                st.markdown("<div class='prediction-card'>", unsafe_allow_html=True)
+                top_class, top_confidence = st.session_state.predictions[0]
+                st.markdown(f"### Primary Prediction: Grade {top_class}")
+                st.markdown(f"### Confidence: {top_confidence:.2f}%")
+                st.markdown("</div>", unsafe_allow_html=True)
+                
+                # Display confidence bar for top prediction
+                st.progress(top_confidence / 100)
+                
+                # Display top 5 predictions
+                st.markdown("### Top 5 Predictions")
+                st.markdown("<div class='top-predictions'>", unsafe_allow_html=True)
+                
+                # Create a Streamlit container for the predictions
+                for class_name, confidence in st.session_state.predictions:
+                    col_label, col_bar, col_value = st.columns([2, 6, 2])
+                    with col_label:
+                        st.write(f"Grade {class_name}")
+                    with col_bar:
+                        st.progress(confidence / 100)
+                    with col_value:
+                        st.write(f"{confidence:.2f}%")
+                
+                st.markdown("</div>", unsafe_allow_html=True)
+        else:
+            st.info("Upload an image and click 'Predict' to see the results")
+    
+    # Footer
     st.markdown("---")
-    st.markdown("Tạo bởi ❤️ với Streamlit")
-
-def load_model_and_scaler():
-    """Load the trained model and scaler"""
-    try:
-        model = tf.keras.models.load_model('mlp_model.h5')
-        # Tải scaler đã lưu
-        scaler = joblib.load('scaler.pkl')
-        return model, scaler
-    except Exception as e:
-        st.error(f"Error loading model or scaler: {str(e)}")
-        return None, None
-
-def color_histogram(image, bins=16):
-    """
-    Tính histogram màu cho ảnh RGB
-
-    Args:
-        image (np.ndarray): Ảnh đầu vào
-        bins (int): Số lượng bins của histogram
-
-    Returns:
-        np.ndarray: Histogram màu được chuẩn hóa
-    """
-    # Kiểm tra và chuyển đổi ảnh
-    if image is None or image.size == 0:
-        raise ValueError("Ảnh không hợp lệ")
-
-    # Đảm bảo ảnh ở dạng uint8
-    if image.dtype != np.uint8:
-        image = (image * 255).astype(np.uint8)
-
-    # Tính histogram cho từng kênh màu
-    hist_r = cv2.calcHist([image], [0], None, [bins], [0, 256]).flatten()
-    hist_g = cv2.calcHist([image], [1], None, [bins], [0, 256]).flatten()
-    hist_b = cv2.calcHist([image], [2], None, [bins], [0, 256]).flatten()
-
-    # Chuẩn hóa histogram
-    hist_r = hist_r / np.sum(hist_r) if np.sum(hist_r) > 0 else hist_r
-    hist_g = hist_g / np.sum(hist_g) if np.sum(hist_g) > 0 else hist_g
-    hist_b = hist_b / np.sum(hist_b) if np.sum(hist_b) > 0 else hist_b
-
-    return np.concatenate([hist_r, hist_g, hist_b])
-
-def color_moments(image):
-    """
-    Tính các moment màu cho ảnh
-
-    Args:
-        image (np.ndarray): Ảnh đầu vào
-
-    Returns:
-        np.ndarray: Các moment màu
-    """
-    # Kiểm tra và chuyển đổi ảnh
-    if image is None or image.size == 0:
-        raise ValueError("Ảnh không hợp lệ")
-
-    # Đảm bảo ảnh ở dạng float và chuẩn hóa
-    img = image.astype(np.float32) / 255.0 if image.max() > 1 else image.astype(np.float32)
-
-    moments = []
-    for i in range(3):  # Cho mỗi kênh màu
-        channel = img[:,:,i]
-
-        # Tính các moment
-        mean = np.mean(channel)
-        std = np.std(channel)
-        skewness = np.mean(((channel - mean) / (std + 1e-8)) ** 3)
-
-        moments.extend([mean, std, skewness])
-
-    return np.array(moments)
-
-def dominant_color_descriptor(image, k=3):
-    """
-    Xác định các màu chính thống trị trong ảnh
-
-    Args:
-        image (np.ndarray): Ảnh đầu vào
-        k (int): Số lượng màu chủ đạo
-
-    Returns:
-        np.ndarray: Các màu chủ đạo và tỷ lệ
-    """
-    # Kiểm tra và chuyển đổi ảnh
-    if image is None or image.size == 0:
-        raise ValueError("Ảnh không hợp lệ")
-
-    # Đảm bảo ảnh ở dạng uint8
-    if image.dtype != np.uint8:
-        image = (image * 255).astype(np.uint8)
-
-    # Reshape ảnh thành mảng pixel
-    pixels = image.reshape(-1, 3)
-
-    # Các tham số cho K-means
-    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.2)
-    flags = cv2.KMEANS_RANDOM_CENTERS
-
-    try:
-        # Thực hiện phân cụm K-means
-        _, labels, centers = cv2.kmeans(
-            pixels.astype(np.float32), k, None, criteria, 10, flags
-        )
-
-        # Tính toán số lượng và tỷ lệ của từng cụm
-        unique, counts = np.unique(labels, return_counts=True)
-        percentages = counts / len(labels)
-
-        # Kết hợp các màu và tỷ lệ
-        dominant_colors = centers.flatten()
-        color_percentages = percentages
-
-        return np.concatenate([dominant_colors, color_percentages])
-    except Exception:
-        # Trả về mảng 0 nếu có lỗi
-        return np.zeros(2 * k)
-
-def color_coherence_vector(image, k=3):
-    """
-    Tính vector liên kết màu
-
-    Args:
-        image (np.ndarray): Ảnh đầu vào
-        k (int): Số lượng vùng
-
-    Returns:
-        np.ndarray: Vector liên kết màu
-    """
-    # Kiểm tra và chuyển đổi ảnh
-    if image is None or image.size == 0:
-        raise ValueError("Ảnh không hợp lệ")
-
-    # Chuyển sang ảnh xám
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-
-    # Đảm bảo ảnh ở dạng uint8
-    if gray.dtype != np.uint8:
-        gray = np.uint8(gray)
-
-    # Áp dụng Otsu's thresholding
-    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-
-    # Phân tích thành phần liên thông
-    num_labels, labels = cv2.connectedComponents(binary)
-
-    ccv = []
-    for i in range(1, min(k+1, num_labels)):
-        region_mask = (labels == i)
-        total_pixels = np.sum(region_mask)
-        coherent_pixels = total_pixels
-
-        ccv.extend([coherent_pixels, total_pixels])
-
-    # Đảm bảo độ dài vector
-    while len(ccv) < 2 * k:
-        ccv.append(0)
-
-    return np.array(ccv)
-
-def edge_features(image, bins=16):
-    """
-    Trích xuất đặc trưng cạnh từ ảnh
-
-    Args:
-        image (np.ndarray): Ảnh đầu vào
-        bins (int): Số lượng bins của histogram
-
-    Returns:
-        np.ndarray: Đặc trưng cạnh
-    """
-    # Kiểm tra và chuyển đổi ảnh
-    if image is None or image.size == 0:
-        raise ValueError("Ảnh không hợp lệ")
-
-    # Chuyển sang ảnh xám
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-
-    # Đảm bảo ảnh ở dạng uint8
-    if gray.dtype != np.uint8:
-        gray = np.uint8(gray)
-
-    # Tính Sobel edges
-    sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
-    sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
-    sobel_mag = np.sqrt(sobel_x**2 + sobel_y**2)
-
-    # Chuẩn hóa độ lớn Sobel
-    sobel_mag = np.uint8(255 * sobel_mag / np.max(sobel_mag))
-
-    # Tính histogram của Sobel magnitude
-    sobel_hist = cv2.calcHist([sobel_mag], [0], None, [bins], [0, 256]).flatten()
-    sobel_hist = sobel_hist / np.sum(sobel_hist) if np.sum(sobel_hist) > 0 else sobel_hist
-
-    # Tính mật độ cạnh bằng Canny
-    canny_edges = cv2.Canny(gray, 100, 200)
-    edge_density = np.sum(canny_edges) / (gray.shape[0] * gray.shape[1])
-
-    return np.concatenate([sobel_hist, [edge_density]])
-
-
-
-def histogram_in_color_space(image, color_space='HSV', bins=16):
-    """
-    Tính histogram của ảnh trong một không gian màu mới.
-    """
-    if color_space == 'HSV':
-        converted = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-    elif color_space == 'LAB':
-        converted = cv2.cvtColor(image, cv2.COLOR_RGB2Lab)
-    else:
-        raise ValueError("Unsupported color space")
-
-    histograms = []
-    for i in range(3):  # 3 kênh màu
-        hist = cv2.calcHist([converted], [i], None, [bins], [0, 256]).flatten()
-        hist = hist / np.sum(hist)
-        histograms.append(hist)
-
-    return np.concatenate(histograms)
-
-def glcm_features(image, distances=[1, 2, 3], angles=[0, np.pi/4, np.pi/2, 3*np.pi/4], levels=256):
-    """
-    Tính các đặc trưng GLCM của ảnh grayscale.
-    """
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-
-    # Đảm bảo ảnh ở dạng uint8
-    if gray.dtype != np.uint8:
-        gray = (gray * 255).astype(np.uint8)
-
-    glcm = graycomatrix(gray, distances=distances, angles=angles, levels=levels, symmetric=True, normed=True)
-
-    features = []
-    # Các thuộc tính phổ biến: contrast, homogeneity, energy, correlation
-    for prop in ['contrast', 'homogeneity', 'energy', 'correlation']:
-        features.extend(graycoprops(glcm, prop).flatten())
-
-    return np.array(features)
-
-
-def gabor_features(image, kernels=None):
-    """
-    Tính các đặc trưng từ bộ lọc Gabor.
-    """
-    if kernels is None:
-        kernels = []
-        for theta in np.arange(0, np.pi, np.pi / 4):  # Các góc từ 0 đến 180 độ
-            for sigma in [1, 3]:  # Các giá trị sigma
-                for frequency in [0.1, 0.5]:  # Các tần số
-                    kernel = cv2.getGaborKernel((9, 9), sigma, theta, 1/frequency, gamma=0.5, ktype=cv2.CV_32F)
-                    kernels.append(kernel)
-
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    features = []
-    for kernel in kernels:
-        filtered = cv2.filter2D(gray, cv2.CV_32F, kernel)
-        features.append(filtered.mean())
-        features.append(filtered.var())
-
-    return np.array(features)
-
-def wavelet_features(image, wavelet='db1', level=3):
-    """
-    Trích xuất các hệ số wavelet từ ảnh grayscale.
-    """
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    coeffs = pywt.wavedec2(gray, wavelet, level=level)
-    features = []
-    for coeff in coeffs:
-        if isinstance(coeff, tuple):  # Chi tiết (LH, HL, HH)
-            for subband in coeff:
-                features.append(subband.mean())
-                features.append(subband.var())
-        else:  # Xấp xỉ (LL)
-            features.append(coeff.mean())
-            features.append(coeff.var())
-
-    return np.array(features)
-
-def fractal_dimension(image):
-    """
-    Tính Fractal Dimension của ảnh.
-    """
-    # Chuyển đổi ảnh sang grayscale
-    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-
-    # Đảm bảo ảnh ở dạng uint8
-    if gray.dtype != np.uint8:
-        gray = (gray * 255).astype(np.uint8)
-
-    # Áp dụng Canny để tìm cạnh
-    edges = cv2.Canny(gray, 100, 200)
-
-    # Tính fractal dimension dựa trên phương pháp box-counting
-    sizes = []
-    counts = []
-    for size in range(2, 65, 2):  # Kích thước hộp từ 2 đến 64
-        region_size = (edges.shape[0] // size, edges.shape[1] // size)
-        count = np.sum(cv2.resize(edges, region_size, interpolation=cv2.INTER_AREA) > 0)
-        sizes.append(size)
-        counts.append(count)
-
-    # Tính log-log slope
-    log_sizes = np.log(sizes)
-    log_counts = np.log(counts)
-    slope, _ = np.polyfit(log_sizes, log_counts, 1)
-
-    # Trả về giá trị fractal dimension
-    return np.array([slope])
-
-
-def extract_features(image):
-    """
-    Extract multiple features from an image, including edge-based features.
-    """
-    color_hist = color_histogram(image)
-    color_mom = color_moments(image)
-    dom_color = dominant_color_descriptor(image)
-    ccv = color_coherence_vector(image)
-    edges = edge_features(image)
-
-    # Các đặc trưng từ phương pháp mới
-    hsv_hist = histogram_in_color_space(image, color_space='HSV')
-    # lab_hist = histogram_in_color_space(image, color_space='LAB')
-    glcm = glcm_features(image)
-    gabor = gabor_features(image)
-    wavelet = wavelet_features(image)
-    # fractal = fractal_dimension(image)
-
-    # Kết hợp tất cả thành một vector đặc trưng
-    return np.concatenate([
-        color_hist,
-        color_mom,
-        dom_color,
-        ccv,
-        edges,
-        hsv_hist,
-        # lab_hist,
-        glcm,
-        gabor,
-        wavelet,
-        # fractal
-    ])
-
-
-def create_resnet50_feature_extractor(input_shape=(256, 256, 3), num_classes=None):
-    # Xây dựng mô hình ResNet112 đã huấn luyện sẵn từ TensorFlow
-    inputs = layers.Input(shape=input_shape)
-
-    # Thêm lớp Lambda để tiền xử lý ảnh
-    x = Lambda(preprocess_input, output_shape=input_shape)(inputs)  # Xử lý ảnh đầu vào
-
-    # Sử dụng mô hình ResNet112 đã được huấn luyện sẵn
-    resnet50_model = ResNet50(include_top=False, weights='imagenet', input_tensor=x)
-
-    # Trích xuất đặc trưng từ mô hình ResNet112
-    x = layers.GlobalAveragePooling2D()(resnet50_model.output)
-
-    if num_classes:
-        x = layers.Dense(num_classes, activation='softmax')(x)  # Thêm lớp phân loại (nếu có)
-
-    return models.Model(inputs=inputs, outputs=x)
-
-def extract_features(image):
-    """
-    Extract multiple features from an image, including edge-based features.
-    """
-    color_hist = color_histogram(image)
-    color_mom = color_moments(image)
-    dom_color = dominant_color_descriptor(image)
-    ccv = color_coherence_vector(image)
-    edges = edge_features(image)
-
-    # Các đặc trưng từ phương pháp mới
-    hsv_hist = histogram_in_color_space(image, color_space='HSV')
-    # lab_hist = histogram_in_color_space(image, color_space='LAB')
-    glcm = glcm_features(image)
-    gabor = gabor_features(image)
-    wavelet = wavelet_features(image)
-    # fractal = fractal_dimension(image)
-
-    # Kết hợp tất cả thành một vector đặc trưng
-    return np.concatenate([
-        color_hist,
-        color_mom,
-        dom_color,
-        ccv,
-        edges,
-        hsv_hist,
-        # lab_hist,
-        glcm,
-        gabor,
-        wavelet,
-        # fractal
-    ])
-
-def preprocess_image(image, scaler):
-    image=np.array(image)
-    img_size=(256, 256)
-    img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    img = cv2.resize(img, img_size)
-    img_array = img.astype('float32') / 255.0
-
-    features1 = np.array(extract_features(img_array))
-    resnet_extractor = create_resnet50_feature_extractor()
-    features2 = resnet_extractor.predict(np.expand_dims(img_array, axis=0))
-    print(f"Shape of features1: {features1.shape}")
-    print(f"Shape of features2: {features2.shape}")
-    features = np.concatenate([np.expand_dims(features1, axis=0), features2], axis=1)  # Concatenate along axis 0
-
-    # Scale features using the provided scaler
-    scaled_features = scaler.transform(features)  # Reshape for scaling
-
-    return scaled_features
-
-def get_top_predictions(prediction, class_names):
-    # Extract the top 5 predictions with confidence values
-    probabilities = tf.nn.softmax(prediction[0]).numpy()
-    top_indices = np.argsort(probabilities)[-5:][::-1]
-    return [(class_names[i], probabilities[i] * 100) for i in top_indices]
+    st.markdown("Made with ❤️ using Streamlit")
 
 if __name__ == "__main__":
     main()

requirements.txt

@@ -1,12 +1,4 @@
 streamlit 
 tensorflow 
 opencv-python 
-pillow
-scikit-learn
-matplotlib
-transformers
-torch
-torchvision
-scikit-image
-PyWavelets
-cloudinary
+pillow