Update app.py

app.py

@@ -1,16 +1,35 @@
-import streamlit as st
-import tensorflow as tf
-import numpy as np
+import os
+import random
+import string
+import io
+import joblib
 import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers, models
+from tensorflow.keras.applications import ResNet50, EfficientNetB0
+from tensorflow.keras.applications.resnet import preprocess_input
+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 keras.applications import ResNet50
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import (
+    confusion_matrix,
+    ConfusionMatrixDisplay,
+    accuracy_score,
+    precision_score,
+    recall_score,
+    f1_score
+)
+import matplotlib.pyplot as plt
+from skimage.feature import graycomatrix, graycoprops
 from PIL import Image
-import io
-import torch
+import streamlit as st
 import cloudinary
 import cloudinary.uploader
 from cloudinary.utils import cloudinary_url
-import os
-import random
-import string
+import torch
 # Cloudinary Configuration
 cloudinary.config(
     cloud_name = os.getenv("CLOUD"),
@@ -93,10 +112,396 @@ def resize_to_square(image):
     # Copy the image into center of result image
     new_img[y_center:y_center+image.shape[0],
             x_center:x_center+image.shape[1]] = image
-
     return new_img
+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]])
+
+
+import pywt  # Thư viện xử lý wavelet
 
+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)
+
+from skimage.feature import local_binary_pattern
+from skimage.color import rgb2gray
+from skimage.measure import shannon_entropy
+from skimage.feature import hog
+
+def illumination_features(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    mean_brightness = np.mean(gray)
+    contrast = np.std(gray)
+    return np.array([mean_brightness, contrast])
+
+def saturation_index(image):
+    hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+    s_channel = hsv[:, :, 1]
+    mean_saturation = np.mean(s_channel)
+    std_saturation = np.std(s_channel)
+    return np.array([mean_saturation, std_saturation])
+
+def local_binary_pattern_features(image, num_points=24, radius=3):
+    gray = rgb2gray(image)
+    lbp = local_binary_pattern(gray, num_points, radius, method="uniform")
+    hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, num_points + 3), range=(0, num_points + 2))
+    hist = hist / np.sum(hist)
+    return hist
+
+def fourier_transform_features(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    f_transform = np.fft.fft2(gray)
+    f_shift = np.fft.fftshift(f_transform)
+    magnitude_spectrum = 20 * np.log(np.abs(f_shift) + 1)
+    mean_frequency = np.mean(magnitude_spectrum)
+    std_frequency = np.std(magnitude_spectrum)
+    return np.array([mean_frequency, std_frequency])
+
+def fractal_dimension(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    size = gray.shape[0] * gray.shape[1]
+    edges = cv2.Canny(gray, 100, 200)
+    count = np.sum(edges > 0)
+    fractal_dim = np.log(count + 1) / np.log(size)
+    return np.array([fractal_dim])
+
+
+def glossiness_index(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    glossiness = np.mean(gray[binary == 255])
+    return np.array([glossiness])
+
+def histogram_oriented_gradients(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    features, _ = hog(gray, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), visualize=True)
+    return features
+
+def color_entropy(image):
+    entropy = shannon_entropy(image)
+    return np.array([entropy])
+
+def spatial_color_distribution(image, grid_size=4):
+    h, w, _ = image.shape
+    features = []
+    for i in range(grid_size):
+        for j in range(grid_size):
+            x_start = i * h // grid_size
+            x_end = (i + 1) * h // grid_size
+            y_start = j * w // grid_size
+            y_end = (j + 1) * w // grid_size
+            patch = image[x_start:x_end, y_start:y_end]
+            hist = cv2.calcHist([patch], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256]).flatten()
+            hist = hist / np.sum(hist)
+            features.extend(hist)
+    return np.array(features)
+
+def uniform_region_features(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    num_labels, labels = cv2.connectedComponents(gray)
+    unique, counts = np.unique(labels, return_counts=True)
+    uniformity = np.sum((counts / np.sum(counts)) ** 2)
+    return np.array([uniformity])
+
+def color_space_features(image):
+    ycbcr = cv2.cvtColor(image, cv2.COLOR_RGB2YCrCb)
+    ycbcr_hist = cv2.calcHist([ycbcr], [1, 2], None, [16, 16], [0, 256, 0, 256]).flatten()
+    lab = cv2.cvtColor(image, cv2.COLOR_RGB2Lab)
+    lab_hist = cv2.calcHist([lab], [1, 2], None, [16, 16], [0, 256, 0, 256]).flatten()
+    ycbcr_hist = ycbcr_hist / np.sum(ycbcr_hist)
+    lab_hist = lab_hist / np.sum(lab_hist)
+    return np.concatenate([ycbcr_hist, lab_hist])
 @st.cache_resource
+def extract_features(image):
+    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)
+    hsv_hist = histogram_in_color_space(image, color_space='HSV')
+    glcm = glcm_features(image)
+    gabor = gabor_features(image)
+    wavelet = wavelet_features(image)
+    illumination = illumination_features(image)
+    saturation = saturation_index(image)
+    lbp = local_binary_pattern_features(image)
+    fourier = fourier_transform_features(image)
+    fractal = fractal_dimension(image)
+    return np.concatenate([
+        color_hist,
+        color_mom,
+        dom_color,
+        ccv,
+        edges,
+        hsv_hist,
+        glcm,
+        gabor,
+        wavelet,
+        illumination,
+        saturation,
+        lbp,
+        fourier,
+        fractal,
+    ])
+
 def load_models():
     """Load both object detection and classification models"""
     # Load object detection model
@@ -106,10 +511,28 @@ def load_models():
     object_detection_model.eval()
 
     # Load classification model
-    classification_model = tf.keras.models.load_model('custom_model.h5')
+    classification_model = tf.keras.models.load_model('mlp_model.h5')
 
     return object_detection_model, classification_model, device
 
+def create_efficientnetb0_feature_extractor(input_shape=(256, 256, 3), num_classes=None):
+    # Xây dựng mô hình EfficientNetB0 đã 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 EfficientNetB0 đã được huấn luyện sẵn
+    efficientnetb0_model = EfficientNetB0(include_top=False, weights='imagenet', input_tensor=x)
+
+    # Trích xuất đặc trưng từ mô hình EfficientNetB0
+    x = layers.GlobalAveragePooling2D()(efficientnetb0_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 perform_object_detection(image, model, device):
     original_size = image.size
     target_size = (256, 256)
@@ -164,10 +587,28 @@ def perform_object_detection(image, model, device):
 
 def preprocess_image(image):
     """Preprocess the image for classification"""
+    # Convert image to numpy array and resize
     img_array = np.array(image)
     img_array = cv2.resize(img_array, (256, 256))
-    img_array = img_array.astype('float32') / 255.0
-    return img_array
+
+    # Extract custom features (ensure this returns a 1D array)
+    features = extract_features(img_array)
+    features = features.flatten()  # Ensure 1D
+
+    # Extract EfficientNet features
+    model_extractor = create_efficientnetb0_feature_extractor()
+    model_features = model_extractor.predict(np.expand_dims(img_array, axis=0))
+    model_features = model_features.flatten()  # Convert to 1D array
+
+    # Combine features
+    features_combined = np.concatenate([features, model_features])
+    features_combined = features_combined.reshape(1, -1)  # Reshape to 2D for scaler
+
+    # Load and apply scaler
+    scaler = joblib.load('scaler.pkl')
+    processed_image = scaler.transform(features_combined)
+
+    return processed_image
 
 def get_top_predictions(prediction, class_names, top_k=5):
     """Get top k predictions with their probabilities"""
@@ -218,13 +659,11 @@ def main():
                     all_predictions = []
                     all_image=[]
                     for idx, cropped_image in cropped_images:
-                        processed_image = preprocess_image(cropped_image)
-                        prediction = classification_model.predict(
-                            np.expand_dims(processed_image, axis=0)
-                        )
-                        top_predictions = get_top_predictions(prediction, class_names)
-                        all_predictions.append([idx,top_predictions])
-                        all_image.append(cropped_image)
+                      processed_image = preprocess_image(cropped_image)
+                      prediction = classification_model.predict(processed_image)
+                      top_predictions = get_top_predictions(prediction, class_names)
+                      all_predictions.append([idx,top_predictions])
+                      all_image.append(cropped_image)
                     # Store in session state
                     st.session_state.predictions = all_predictions
                     st.session_state.image = all_image