Spaces:
Sleeping
Sleeping
File size: 3,588 Bytes
9643386 93e8de0 9643386 93e8de0 9643386 93e8de0 9643386 93e8de0 9643386 93e8de0 9643386 93e8de0 9643386 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 |
import gradio as gr
import numpy as np
import pandas as pd
import cv2
import pickle
from skimage.color import rgb2hsv
from skimage.measure import shannon_entropy
from scipy.ndimage import generic_filter
# Load the pre-trained SVR model, MinMaxScaler, and LabelEncoder from pickle files
model_path = "svr_model.pkl" # Replace with the path to your pickle file
scaler_path = "minmax_scaler.pkl" # Replace with the path to your MinMaxScaler pickle file
encoder_path = "label_encoder.pkl" # Replace with the path to your LabelEncoder pickle file
# Load the pickle files
with open(model_path, 'rb') as f:
svr_model = pickle.load(f)
with open(scaler_path, 'rb') as f:
scaler = pickle.load(f)
with open(encoder_path, 'rb') as f:
label_encoder = pickle.load(f)
# Feature extraction function
def extract_features(image):
image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# Extract RGB means
meanr = np.mean(image[:, :, 0])
meang = np.mean(image[:, :, 1])
meanb = np.mean(image[:, :, 2])
# Convert to HSI and compute HHR
hsv_image = rgb2hsv(image)
hue = hsv_image[:, :, 0]
high_hue_pixels = np.sum(hue > 0.95)
total_pixels = hue.size
HHR = high_hue_pixels / total_pixels
# Convert to Grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
# Compute Entropy and Brightness
Ent = shannon_entropy(gray_image)
B = np.mean(gray_image)
# Sliding window filters
def g1_filter(window):
return window[4] - np.min(window)
def g2_filter(window):
return np.max(window) - window[4]
def g3_filter(window):
return window[4] - np.mean(window)
def g4_filter(window):
return np.std(window)
def g5_filter(window):
return window[4]
g1 = generic_filter(gray_image, g1_filter, size=3).mean()
g2 = generic_filter(gray_image, g2_filter, size=3).mean()
g3 = generic_filter(gray_image, g3_filter, size=3).mean()
g4 = generic_filter(gray_image, g4_filter, size=3).mean()
g5 = generic_filter(gray_image, g5_filter, size=3).mean()
return {
"meanr": meanr,
"meang": meang,
"meanb": meanb,
"HHR": HHR,
"Ent": Ent,
"B": B,
"g1": g1,
"g2": g2,
"g3": g3,
"g4": g4,
"g5": g5,
}
# Prediction function
def predict(image, gender, age):
# Extract image features
features = extract_features(image)
# Encode gender using LabelEncoder
gender_encoded = label_encoder.transform([gender])[0] # Transform the gender to the correct encoded value
# Add gender and age to the feature dictionary
features["gender"] = gender_encoded
features["age"] = age
# Convert features to DataFrame
features_df = pd.DataFrame([features])
# Scale the features using MinMaxScaler
features_scaled = scaler.transform(features_df)
# Predict using the SVR model
prediction = svr_model.predict(features_scaled)
# Return the prediction (you can format this depending on the model output)
return prediction[0]
# Gradio Interface
interface = gr.Interface(
fn=predict,
inputs=[
gr.Image(label="Upload Image"),
gr.Dropdown(choices=["Male", "Female"], label="Gender"),
gr.Slider(0, 100, step=1, label="Age"),
],
outputs="number",
title="Image-based Prediction App",
description="Upload an image, enter your gender and age, and get predictions using the pre-trained SVR model."
)
# Launch the app
interface.launch()
|