Spaces:
Sleeping
Sleeping
| # import streamlit as st | |
| # # Set title of the app | |
| # st.title("Simple Streamlit App") | |
| # # Add text input | |
| # user_input = st.text_input("Enter your name:") | |
| # # Display the input value | |
| # if user_input: | |
| # st.write(f"Hello, {user_input}!") | |
| # import streamlit as st | |
| # from tensorflow.keras.models import load_model | |
| # from tensorflow.keras.preprocessing import image | |
| # import numpy as np | |
| # from PIL import Image | |
| # # Load the pre-trained models | |
| # @st.cache_resource | |
| # def load_models(): | |
| # model1 = load_model('name_model_inception.h5') # Update with your Hugging Face model path | |
| # model2 = load_model('type_model_inception.h5') # Update with your Hugging Face model path | |
| # return model1, model2 | |
| # model1, model2 = load_models() | |
| # # Label mappings | |
| # label_map1 = { | |
| # 0: "Banana", 1: "Cucumber", 2: "Grape", 3: "Kaki", 4: "Papaya", | |
| # 5: "Peach", 6: "Pear", 7: "Pepper", 8: "Strawberry", 9: "Watermelon", 10: "Tomato" | |
| # } | |
| # label_map2 = { | |
| # 0: "Good", 1: "Mild", 2: "Rotten" | |
| # } | |
| # # Streamlit app layout | |
| # st.title("Fruit Classifier") | |
| # # Upload image | |
| # uploaded_file = st.file_uploader("Choose an image of a fruit", type=["jpg", "jpeg", "png"]) | |
| # if uploaded_file is not None: | |
| # # Display the uploaded image | |
| # img = Image.open(uploaded_file) | |
| # st.image(img, caption="Uploaded Image", use_column_width=True) | |
| # # Preprocess the image | |
| # img = img.resize((224, 224)) # Resize image to match the model input | |
| # img_array = image.img_to_array(img) | |
| # img_array = np.expand_dims(img_array, axis=0) | |
| # img_array = img_array / 255.0 # Normalize the image | |
| # # Make predictions | |
| # pred1 = model1.predict(img_array) | |
| # pred2 = model2.predict(img_array) | |
| # predicted_class1 = np.argmax(pred1, axis=1) | |
| # predicted_class2 = np.argmax(pred2, axis=1) | |
| # # Display results | |
| # st.write(f"**Type Detection**: {label_map1[predicted_class1[0]]}") | |
| # st.write(f"**Condition Detection**: {label_map2[predicted_class2[0]]}") | |
| # !git clone 'https://github.com/facebookresearch/detectron2' | |
| # dist = distutils.core.run_setup("./detectron2/setup.py") | |
| # !python -m pip install {' '.join([f"'{x}'" for x in dist.install_requires])} | |
| # sys.path.insert(0, os.path.abspath('./detectron2')) | |
| # import streamlit as st | |
| # import numpy as np | |
| # import cv2 | |
| # import warnings | |
| # # Suppress warnings | |
| # warnings.filterwarnings("ignore", category=FutureWarning) | |
| # warnings.filterwarnings("ignore", category=UserWarning) | |
| # # Try importing TensorFlow | |
| # try: | |
| # from tensorflow.keras.models import load_model | |
| # from tensorflow.keras.preprocessing import image | |
| # except ImportError: | |
| # st.error("Failed to import TensorFlow. Please make sure it's installed correctly.") | |
| # # Try importing PyTorch and Detectron2 | |
| # try: | |
| # import torch | |
| # from detectron2.engine import DefaultPredictor | |
| # from detectron2.config import get_cfg | |
| # from detectron2.utils.visualizer import Visualizer | |
| # from detectron2.data import MetadataCatalog | |
| # except ImportError: | |
| # st.error("Failed to import PyTorch or Detectron2. Please make sure they're installed correctly.") | |
| # # Load the trained models | |
| # try: | |
| # model_path_name = 'name_model_inception.h5' | |
| # model_path_quality = 'type_model_inception.h5' | |
| # detectron_config_path = 'watermelon.yaml' | |
| # detectron_weights_path = 'Watermelon_model.pth' | |
| # model_name = load_model(model_path_name) | |
| # model_quality = load_model(model_path_quality) | |
| # except Exception as e: | |
| # st.error(f"Failed to load models: {str(e)}") | |
| # # Streamlit app title | |
| # st.title("Watermelon Quality and Damage Detection") | |
| # # Upload image | |
| # uploaded_file = st.file_uploader("Choose a watermelon image...", type=["jpg", "jpeg", "png"]) | |
| # if uploaded_file is not None: | |
| # try: | |
| # # Load the image | |
| # img = image.load_img(uploaded_file, target_size=(224, 224)) | |
| # img_array = image.img_to_array(img) | |
| # img_array = np.expand_dims(img_array, axis=0) | |
| # img_array /= 255.0 | |
| # # Display uploaded image | |
| # st.image(uploaded_file, caption="Uploaded Image", use_column_width=True) | |
| # # Predict watermelon name | |
| # pred_name = model_name.predict(img_array) | |
| # predicted_name = 'Watermelon' | |
| # # Predict watermelon quality | |
| # pred_quality = model_quality.predict(img_array) | |
| # predicted_class_quality = np.argmax(pred_quality, axis=1) | |
| # # Define labels for watermelon quality | |
| # label_map_quality = { | |
| # 0: "Good", | |
| # 1: "Mild", | |
| # 2: "Rotten" | |
| # } | |
| # predicted_quality = label_map_quality[predicted_class_quality[0]] | |
| # # Display predictions | |
| # st.write(f"Fruit Type Detection: {predicted_name}") | |
| # st.write(f"Fruit Quality Classification: {predicted_quality}") | |
| # # If the quality is 'Mild' or 'Rotten', pass the image to the mask detection model | |
| # if predicted_quality in ["Mild", "Rotten"]: | |
| # st.write("Passing the image to the mask detection model for damage detection...") | |
| # # Load the image again for the mask detection (Detectron2 requires the original image) | |
| # im = cv2.imdecode(np.fromstring(uploaded_file.read(), np.uint8), 1) | |
| # # Setup Detectron2 configuration for watermelon | |
| # cfg = get_cfg() | |
| # cfg.merge_from_file(detectron_config_path) | |
| # cfg.MODEL.WEIGHTS = detectron_weights_path | |
| # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 | |
| # cfg.MODEL.DEVICE = 'cpu' # Use CPU for inference | |
| # predictor = DefaultPredictor(cfg) | |
| # predictor.model.load_state_dict(torch.load(detectron_weights_path, map_location=torch.device('cpu'))) | |
| # # Run prediction on the image | |
| # outputs = predictor(im) | |
| # # Visualize the predictions | |
| # v = Visualizer(im[:, :, ::-1], MetadataCatalog.get(cfg.DATASETS.TRAIN[0]), scale=0.8) | |
| # out = v.draw_instance_predictions(outputs["instances"].to("cpu")) | |
| # # Display the output | |
| # st.image(out.get_image()[:, :, ::-1], caption="Detected Damage", use_column_width=True) | |
| # except Exception as e: | |
| # st.error(f"An error occurred during processing: {str(e)}") | |
| # import streamlit as st | |
| # import numpy as np | |
| # import cv2 | |
| # import warnings | |
| # import os | |
| # # Suppress warnings | |
| # warnings.filterwarnings("ignore", category=FutureWarning) | |
| # warnings.filterwarnings("ignore", category=UserWarning) | |
| # # Try importing TensorFlow | |
| # try: | |
| # from tensorflow.keras.models import load_model | |
| # from tensorflow.keras.preprocessing import image | |
| # except ImportError: | |
| # st.error("Failed to import TensorFlow. Please make sure it's installed correctly.") | |
| # # Try importing PyTorch and Detectron2 | |
| # try: | |
| # import torch | |
| # import detectron2 | |
| # except ImportError: | |
| # with st.spinner("Installing PyTorch and Detectron2..."): | |
| # os.system("pip install torch torchvision") | |
| # os.system("pip install 'git+https://github.com/facebookresearch/detectron2.git'") | |
| # import torch | |
| # import detectron2 | |
| # from detectron2.engine import DefaultPredictor | |
| # from detectron2.config import get_cfg | |
| # from detectron2.utils.visualizer import Visualizer | |
| # from detectron2.data import MetadataCatalog | |
| # # Load the trained models | |
| # @st.cache_resource | |
| # def load_models(): | |
| # try: | |
| # model_path_name = 'name_model_inception.h5' | |
| # model_path_quality = 'type_model_inception.h5' | |
| # model_name = load_model(model_path_name) | |
| # model_quality = load_model(model_path_quality) | |
| # return model_name, model_quality | |
| # except Exception as e: | |
| # st.error(f"Failed to load models: {str(e)}") | |
| # return None, None | |
| # model_name, model_quality = load_models() | |
| # # Streamlit app title | |
| # st.title("Watermelon Quality and Damage Detection") | |
| # # Upload image | |
| # uploaded_file = st.file_uploader("Choose a watermelon image...", type=["jpg", "jpeg", "png"]) | |
| # if uploaded_file is not None: | |
| # try: | |
| # # Load the image | |
| # img = image.load_img(uploaded_file, target_size=(224, 224)) | |
| # img_array = image.img_to_array(img) | |
| # img_array = np.expand_dims(img_array, axis=0) | |
| # img_array /= 255.0 | |
| # # Display uploaded image | |
| # st.image(uploaded_file, caption="Uploaded Image", use_column_width=True) | |
| # # Predict watermelon name | |
| # pred_name = model_name.predict(img_array) | |
| # predicted_name = 'Watermelon' | |
| # # Predict watermelon quality | |
| # pred_quality = model_quality.predict(img_array) | |
| # predicted_class_quality = np.argmax(pred_quality, axis=1) | |
| # # Define labels for watermelon quality | |
| # label_map_quality = { | |
| # 0: "Good", | |
| # 1: "Mild", | |
| # 2: "Rotten" | |
| # } | |
| # predicted_quality = label_map_quality[predicted_class_quality[0]] | |
| # # Display predictions | |
| # st.write(f"Fruit Type Detection: {predicted_name}") | |
| # st.write(f"Fruit Quality Classification: {predicted_quality}") | |
| # # If the quality is 'Mild' or 'Rotten', pass the image to the mask detection model | |
| # if predicted_quality in ["Mild", "Rotten"]: | |
| # st.write("Passing the image to the mask detection model for damage detection...") | |
| # # Load the image again for the mask detection (Detectron2 requires the original image) | |
| # im = cv2.imdecode(np.fromstring(uploaded_file.read(), np.uint8), 1) | |
| # # Setup Detectron2 configuration for watermelon | |
| # @st.cache_resource | |
| # def load_detectron_model(): | |
| # cfg = get_cfg() | |
| # cfg.merge_from_file("watermelon.yaml") | |
| # cfg.MODEL.WEIGHTS = "Watermelon_model.pth" | |
| # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 | |
| # cfg.MODEL.DEVICE = 'cpu' # Use CPU for inference | |
| # predictor = DefaultPredictor(cfg) | |
| # return predictor | |
| # predictor = load_detectron_model() | |
| # # Run prediction on the image | |
| # outputs = predictor(im) | |
| # # Visualize the predictions | |
| # v = Visualizer(im[:, :, ::-1], MetadataCatalog.get(cfg.DATASETS.TRAIN[0]), scale=0.8) | |
| # out = v.draw_instance_predictions(outputs["instances"].to("cpu")) | |
| # # Display the output | |
| # st.image(out.get_image()[:, :, ::-1], caption="Detected Damage", use_column_width=True) | |
| # except Exception as e: | |
| # st.error(f"An error occurred during processing: {str(e)}") | |
| # ///////////////////////////////////Working | |
| import streamlit as st | |
| import numpy as np | |
| import cv2 | |
| import warnings | |
| import os | |
| # Suppress warnings | |
| warnings.filterwarnings("ignore", category=FutureWarning) | |
| warnings.filterwarnings("ignore", category=UserWarning) | |
| # Try importing TensorFlow | |
| try: | |
| from tensorflow.keras.models import load_model | |
| from tensorflow.keras.preprocessing import image | |
| except ImportError: | |
| st.error("Failed to import TensorFlow. Please make sure it's installed correctly.") | |
| # Try importing PyTorch and Detectron2 | |
| try: | |
| import torch | |
| import detectron2 | |
| except ImportError: | |
| with st.spinner("Installing PyTorch and Detectron2..."): | |
| os.system("pip install torch torchvision") | |
| os.system("pip install 'git+https://github.com/facebookresearch/detectron2.git'") | |
| import torch | |
| import detectron2 | |
| from detectron2.engine import DefaultPredictor | |
| from detectron2.config import get_cfg | |
| from detectron2.utils.visualizer import Visualizer | |
| from detectron2.data import MetadataCatalog | |
| # # Load the trained models | |
| # @st.cache_resource | |
| # def load_models(): | |
| # try: | |
| # model_path_name = 'name_model_inception.h5' | |
| # model_path_quality = 'type_model_inception.h5' | |
| # model_name = load_model(model_path_name) | |
| # model_quality = load_model(model_path_quality) | |
| # return model_name, model_quality | |
| # except Exception as e: | |
| # st.error(f"Failed to load models: {str(e)}") | |
| # return None, None | |
| # model_name, model_quality = load_models() | |
| # # Setup Detectron2 configuration for watermelon | |
| # @st.cache_resource | |
| # def load_detectron_model(): | |
| # cfg = get_cfg() | |
| # cfg.merge_from_file("watermelon.yaml") | |
| # cfg.MODEL.WEIGHTS = "Watermelon_model.pth" | |
| # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 | |
| # cfg.MODEL.DEVICE = 'cpu' # Use CPU for inference | |
| # predictor = DefaultPredictor(cfg) | |
| # return predictor, cfg | |
| # predictor, cfg = load_detectron_model() | |
| # # Streamlit app title | |
| # st.title("Watermelon Quality and Damage Detection") | |
| # # Upload image | |
| # uploaded_file = st.file_uploader("Choose a watermelon image...", type=["jpg", "jpeg", "png"]) | |
| # if uploaded_file is not None: | |
| # try: | |
| # # Load the image | |
| # img = image.load_img(uploaded_file, target_size=(224, 224)) | |
| # img_array = image.img_to_array(img) | |
| # img_array = np.expand_dims(img_array, axis=0) | |
| # img_array /= 255.0 | |
| # # Display uploaded image | |
| # st.image(uploaded_file, caption="Uploaded Image", use_column_width=True) | |
| # # Predict watermelon name | |
| # pred_name = model_name.predict(img_array) | |
| # predicted_name = 'Watermelon' | |
| # # Predict watermelon quality | |
| # pred_quality = model_quality.predict(img_array) | |
| # predicted_class_quality = np.argmax(pred_quality, axis=1) | |
| # # Define labels for watermelon quality | |
| # label_map_quality = { | |
| # 0: "Good", | |
| # 1: "Mild", | |
| # 2: "Rotten" | |
| # } | |
| # predicted_quality = label_map_quality[predicted_class_quality[0]] | |
| # # Display predictions | |
| # st.write(f"Fruit Type Detection: {predicted_name}") | |
| # st.write(f"Fruit Quality Classification: {predicted_quality}") | |
| # # If the quality is 'Mild' or 'Rotten', pass the image to the mask detection model | |
| # if predicted_quality in ["Mild", "Rotten"]: | |
| # st.write("Passing the image to the mask detection model for damage detection...") | |
| # # Load the image again for the mask detection (Detectron2 requires the original image) | |
| # im = cv2.imdecode(np.fromstring(uploaded_file.read(), np.uint8), 1) | |
| # # Run prediction on the image | |
| # outputs = predictor(im) | |
| # # Visualize the predictions | |
| # v = Visualizer(im[:, :, ::-1], MetadataCatalog.get(cfg.DATASETS.TRAIN[0]), scale=0.8) | |
| # out = v.draw_instance_predictions(outputs["instances"].to("cpu")) | |
| # # Display the output | |
| # st.image(out.get_image()[:, :, ::-1], caption="Detected Damage", use_column_width=True) | |
| # except Exception as e: | |
| # st.error(f"An error occurred during processing: {str(e)}") | |
| # import streamlit as st | |
| # import numpy as np | |
| # import cv2 | |
| # import torch | |
| # from PIL import Image | |
| # from tensorflow.keras.models import load_model | |
| # from tensorflow.keras.preprocessing import image | |
| # from detectron2.engine import DefaultPredictor | |
| # from detectron2.config import get_cfg | |
| # from detectron2.utils.visualizer import Visualizer | |
| # from detectron2.data import MetadataCatalog | |
| # # Suppress warnings | |
| # import warnings | |
| # import tensorflow as tf | |
| # warnings.filterwarnings("ignore") | |
| # tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR) | |
| # @st.cache_resource | |
| # def load_models(): | |
| # model_name = load_model('name_model_inception.h5') | |
| # model_quality = load_model('type_model_inception.h5') | |
| # return model_name, model_quality | |
| # model_name, model_quality = load_models() | |
| # # Detectron2 setup | |
| # @st.cache_resource | |
| # def load_detectron_model(fruit_name): | |
| # cfg = get_cfg() | |
| # cfg.merge_from_file(f"{fruit_name.lower()}.yaml") | |
| # cfg.MODEL.WEIGHTS = f"{fruit_name.lower()}_model.pth" | |
| # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 | |
| # cfg.MODEL.DEVICE = 'cpu' | |
| # predictor = DefaultPredictor(cfg) | |
| # return predictor, cfg | |
| # # Labels | |
| # label_map_name = { | |
| # 0: "Banana", 1: "Cucumber", 2: "Grape", 3: "Kaki", 4: "Papaya", | |
| # 5: "Peach", 6: "Pear", 7: "Pepper", 8: "Strawberry", 9: "Watermelon", | |
| # 10: "Tomato" | |
| # } | |
| # label_map_quality = {0: "Good", 1: "Mild", 2: "Rotten"} | |
| # def predict_fruit(img): | |
| # # Preprocess image | |
| # img = Image.fromarray(img.astype('uint8'), 'RGB') | |
| # img = img.resize((224, 224)) | |
| # x = image.img_to_array(img) | |
| # x = np.expand_dims(x, axis=0) | |
| # x = x / 255.0 | |
| # # Predict | |
| # pred_name = model_name.predict(x) | |
| # pred_quality = model_quality.predict(x) | |
| # predicted_name = label_map_name[np.argmax(pred_name, axis=1)[0]] | |
| # predicted_quality = label_map_quality[np.argmax(pred_quality, axis=1)[0]] | |
| # return predicted_name, predicted_quality, img | |
| # def main(): | |
| # st.title("Fruit Quality and Damage Detection") | |
| # st.write("Upload an image of a fruit to detect its type, quality, and potential damage.") | |
| # uploaded_file = st.file_uploader("Choose a fruit image...", type=["jpg", "jpeg", "png"]) | |
| # if uploaded_file is not None: | |
| # image = Image.open(uploaded_file) | |
| # st.image(image, caption="Uploaded Image", use_column_width=True) | |
| # if st.button("Analyze"): | |
| # predicted_name, predicted_quality, img = predict_fruit(np.array(image)) | |
| # st.write(f"Fruit Type: {predicted_name}") | |
| # st.write(f"Fruit Quality: {predicted_quality}") | |
| # if predicted_name.lower() in ["kaki", "tomato", "strawberry", "pepper", "pear", "peach", "papaya", "watermelon", "grape", "banana", "cucumber"] and predicted_quality in ["Mild", "Rotten"]: | |
| # st.write("Detecting damage...") | |
| # predictor, cfg = load_detectron_model(predicted_name) | |
| # outputs = predictor(cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)) | |
| # v = Visualizer(np.array(img), MetadataCatalog.get(cfg.DATASETS.TRAIN[0]), scale=0.8) | |
| # out = v.draw_instance_predictions(outputs["instances"].to("cpu")) | |
| # st.image(out.get_image(), caption="Damage Detection Result", use_column_width=True) | |
| # else: | |
| # st.write("No damage detection performed for this fruit or quality level.") | |
| # if __name__ == "__main__": | |
| # main() | |
| import streamlit as st | |
| import numpy as np | |
| import cv2 | |
| import torch | |
| import os | |
| from PIL import Image | |
| from tensorflow.keras.models import load_model | |
| from tensorflow.keras.preprocessing import image | |
| from detectron2.engine import DefaultPredictor | |
| from detectron2.config import get_cfg | |
| from detectron2.utils.visualizer import Visualizer | |
| from detectron2.data import MetadataCatalog | |
| # Suppress warnings | |
| import warnings | |
| import tensorflow as tf | |
| warnings.filterwarnings("ignore") | |
| tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR) | |
| def load_models(): | |
| model_name = load_model('name_model_inception.h5') | |
| model_quality = load_model('type_model_inception.h5') | |
| return model_name, model_quality | |
| model_name, model_quality = load_models() | |
| # Detectron2 setup | |
| def load_detectron_model(fruit_name): | |
| cfg = get_cfg() | |
| config_path = os.path.join('utils', f"{fruit_name.lower()}_config.yaml") | |
| cfg.merge_from_file(config_path) | |
| model_path = os.path.join('models', f"{fruit_name.lower()}_model.pth") | |
| cfg.MODEL.WEIGHTS = model_path | |
| cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 | |
| cfg.MODEL.DEVICE = 'cpu' | |
| predictor = DefaultPredictor(cfg) | |
| return predictor, cfg | |
| # Labels | |
| label_map_name = { | |
| 0: "Banana", 1: "Cucumber", 2: "Grape", 3: "Kaki", 4: "Papaya", | |
| 5: "Peach", 6: "Pear", 7: "Pepper", 8: "Strawberry", 9: "Watermelon", | |
| 10: "Tomato" | |
| } | |
| label_map_quality = {0: "Good", 1: "Mild", 2: "Rotten"} | |
| def predict_fruit(img): | |
| # Preprocess image | |
| img = Image.fromarray(img.astype('uint8'), 'RGB') | |
| img = img.resize((224, 224)) | |
| x = image.img_to_array(img) | |
| x = np.expand_dims(x, axis=0) | |
| x = x / 255.0 | |
| # Predict | |
| pred_name = model_name.predict(x) | |
| pred_quality = model_quality.predict(x) | |
| predicted_name = label_map_name[np.argmax(pred_name, axis=1)[0]] | |
| predicted_quality = label_map_quality[np.argmax(pred_quality, axis=1)[0]] | |
| return predicted_name, predicted_quality, img | |
| def main(): | |
| st.title("Fruit Quality and Damage Detection") | |
| st.write("Upload an image of a fruit to detect its type, quality, and potential damage.") | |
| uploaded_file = st.file_uploader("Choose a fruit image...", type=["jpg", "jpeg", "png"]) | |
| if uploaded_file is not None: | |
| image = Image.open(uploaded_file) | |
| st.image(image, caption="Uploaded Image", use_column_width=True) | |
| if st.button("Analyze"): | |
| predicted_name, predicted_quality, img = predict_fruit(np.array(image)) | |
| st.write(f"Fruit Type: {predicted_name}") | |
| st.write(f"Fruit Quality: {predicted_quality}") | |
| if predicted_name.lower() in ["kaki", "tomato", "strawberry", "pepper", "pear", "peach", "papaya", "watermelon", "grape", "banana", "cucumber"] and predicted_quality in ["Mild", "Rotten"]: | |
| st.write("Detecting damage...") | |
| try: | |
| predictor, cfg = load_detectron_model(predicted_name) | |
| outputs = predictor(cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)) | |
| v = Visualizer(np.array(img), MetadataCatalog.get(cfg.DATASETS.TRAIN[0]), scale=0.8) | |
| out = v.draw_instance_predictions(outputs["instances"].to("cpu")) | |
| st.image(out.get_image(), caption="Damage Detection Result", use_column_width=True) | |
| except Exception as e: | |
| st.error(f"Error in damage detection: {str(e)}") | |
| else: | |
| st.write("No damage detection performed for this fruit or quality level.") | |
| if __name__ == "__main__": | |
| main() |