import os import random import shutil from concurrent.futures import ThreadPoolExecutor # Define paths dataset_folder = 'path/to/dataset' train_folder = os.path.join(dataset_folder, 'train') val_folder = os.path.join(dataset_folder, 'validation') # Create validation folder if it doesn't exist os.makedirs(val_folder, exist_ok=True) # Get all label folders inside train folder label_folders = [f for f in os.listdir(train_folder) if os.path.isdir(os.path.join(train_folder, f))] # Function to move images from a specific label folder def process_label_folder(label_folder, num_threads): train_label_folder = os.path.join(train_folder, label_folder) val_label_folder = os.path.join(val_folder, label_folder) # Create corresponding validation label folder os.makedirs(val_label_folder, exist_ok=True) # Get all images in the train/label_folder all_images = os.listdir(train_label_folder) total_images = len(all_images) # Calculate 20% of images for validation val_size = int(total_images * 0.2) # Randomly select 20% of the images for validation val_images = random.sample(all_images, val_size) # Function to move a single image def move_image(image): src = os.path.join(train_label_folder, image) dest = os.path.join(val_label_folder, image) shutil.move(src, dest) # Use ThreadPoolExecutor to move images in parallel with ThreadPoolExecutor(max_workers=num_threads) as executor: executor.map(move_image, val_images) print(f"Moved {val_size} images from {label_folder} to validation folder.") # Main function to get user input for number of threads and process folders def main(): # Ask user for the number of threads num_threads = int(input("Enter the number of threads to use: ")) # Process each label folder using the input number of threads for label_folder in label_folders: process_label_folder(label_folder, num_threads) print("Validation dataset created.") if __name__ == "__main__": main() import numpy as np from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, accuracy_score # Assuming you have true labels and predicted labels y_true = [0, 1, 2, 1, 0, 1, 2, 2, 0] # Replace with your true labels y_pred = [0, 0, 2, 1, 0, 1, 2, 1, 0] # Replace with your predicted labels # Calculate the confusion matrix conf_matrix = confusion_matrix(y_true, y_pred) # Print the confusion matrix print("Confusion Matrix:") print(conf_matrix) # Calculate precision, recall, f1-score, and accuracy for each label precision = precision_score(y_true, y_pred, average=None) recall = recall_score(y_true, y_pred, average=None) f1 = f1_score(y_true, y_pred, average=None) accuracy = accuracy_score(y_true, y_pred) # Print precision, recall, f1-score for each label for i in range(len(precision)): print(f"Label {i}:") print(f" Precision: {precision[i]:.4f}") print(f" Recall: {recall[i]:.4f}") print(f" F1-Score: {f1[i]:.4f}") print() # Print overall accuracy print(f"Overall Accuracy: {accuracy:.4f}") import numpy as np from sklearn.metrics import confusion_matrix # Example true and predicted labels y_true = [0, 1, 2, 1, 0, 1, 2, 2, 0] # Replace with your true labels y_pred = [0, 0, 2, 1, 0, 1, 2, 1, 0] # Replace with your predicted labels # Class names (replace with your actual labels) label_names = ['Class A', 'Class B', 'Class C'] # Calculate the confusion matrix conf_matrix = confusion_matrix(y_true, y_pred) # Print the confusion matrix print("Confusion Matrix:") print(conf_matrix) # Number of classes num_classes = conf_matrix.shape[0] # Initialize lists for precision, recall, and f1-score precision = [] recall = [] f1_score = [] # Calculate precision, recall, and F1-score from confusion matrix for each class for i in range(num_classes): tp = conf_matrix[i, i] # True Positives fp = np.sum(conf_matrix[:, i]) - tp # False Positives fn = np.sum(conf_matrix[i, :]) - tp # False Negatives # Calculate precision, recall, f1-score precision_i = tp / (tp + fp) if (tp + fp) > 0 else 0 recall_i = tp / (tp + fn) if (tp + fn) > 0 else 0 f1_i = 2 * (precision_i * recall_i) / (precision_i + recall_i) if (precision_i + recall_i) > 0 else 0 # Append to lists precision.append(precision_i) recall.append(recall_i) f1_score.append(f1_i) # Print precision, recall, f1-score for each label for i, label in enumerate(label_names): print(f"{label}:") print(f" Precision: {precision[i]:.4f}") print(f" Recall: {recall[i]:.4f}") print(f" F1-Score: {f1_score[i]:.4f}") print() import React, { useState, useEffect } from "react"; import * as tflite from "@tensorflow/tfjs-tflite"; import * as tf from "@tensorflow/tfjs"; function ObjectDetector() { const [model, setModel] = useState(null); const [imageUrl, setImageUrl] = useState(null); const [predictions, setPredictions] = useState([]); // Load the TFLite model useEffect(() => { const loadModel = async () => { const loadedModel = await tflite.loadTFLiteModel('/path_to_your_model.tflite'); setModel(loadedModel); }; loadModel(); }, []); // Handle image input change const handleImageChange = (event) => { const file = event.target.files[0]; if (file) { setImageUrl(URL.createObjectURL(file)); } }; // Run inference on the selected image const runInference = async () => { if (!model || !imageUrl) return; const imageElement = document.getElementById("inputImage"); // Load the image into a tensor const inputTensor = preprocessImage(imageElement, [1, 320, 320, 3]); // Adjust this size based on your model's expected input // Run inference const output = await model.predict(inputTensor); // Extract predictions const [boxes, classes, scores, numDetections] = extractPredictions(output); // Display the predictions const predictionResults = []; for (let i = 0; i < numDetections; i++) { if (scores[i] > 0.5) { // Only display results with confidence > 0.5 predictionResults.push({ class: classes[i], // Map class ID to label if available score: scores[i], bbox: boxes[i], }); } } setPredictions(predictionResults); // Clean up the tensor to free memory tf.dispose([inputTensor]); }; // Function to preprocess image (resize, normalize, and convert to tensor) const preprocessImage = (image, inputShape) => { const tensor = tf.browser.fromPixels(image) // Load image into a tensor .toFloat() .div(tf.scalar(255.0)) // Normalize pixel values to [0, 1] .resizeBilinear([inputShape[1], inputShape[2]]) // Resize to 320x320 or model input size .expandDims(0); // Add batch dimension [1, 320, 320, 3] return tensor; }; // Function to extract bounding boxes, class IDs, and scores from the model output const extractPredictions = (output) => { const boxes = output[0].arraySync(); // Bounding boxes const classes = output[1].arraySync(); // Class IDs const scores = output[2].arraySync(); // Confidence scores const numDetections = output[3].arraySync()[0]; // Number of detected objects return [boxes, classes, scores, numDetections]; }; return (

Object Detection with TFLite

{/* Input: Upload Image */} {/* Display Selected Image */} {imageUrl && (
Input
)} {/* Run Inference Button */} {/* Display Predictions */} {predictions.length > 0 && (

Predictions:

)}
); } export default ObjectDetector; import json import random import os # Load the COCO annotations file coco_file = 'annotations.json' # Path to your COCO annotations file output_dir = 'output_dir/' # Directory to save the split files train_ratio = 0.8 # 80% for training, 20% for validation # Create output directory if it doesn't exist if not os.path.exists(output_dir): os.makedirs(output_dir) # Load COCO annotations with open(coco_file, 'r') as f: coco_data = json.load(f) # Extract images and annotations images = coco_data['images'] annotations = coco_data['annotations'] # Shuffle images to ensure random split random.shuffle(images) # Split images into training and validation sets train_size = int(len(images) * train_ratio) train_images = images[:train_size] val_images = images[train_size:] # Create dictionaries to store image IDs for filtering annotations train_image_ids = {img['id'] for img in train_images} val_image_ids = {img['id'] for img in val_images} # Split annotations based on image IDs train_annotations = [ann for ann in annotations if ann['image_id'] in train_image_ids] val_annotations = [ann for ann in annotations if ann['image_id'] in val_image_ids] # Create train and validation splits for COCO format train_data = { 'images': train_images, 'annotations': train_annotations, 'categories': coco_data['categories'], # Keep categories the same } val_data = { 'images': val_images, 'annotations': val_annotations, 'categories': coco_data['categories'], # Keep categories the same } # Save the new train and validation annotation files train_file = os.path.join(output_dir, 'train_annotations.json') val_file = os.path.join(output_dir, 'val_annotations.json') with open(train_file, 'w') as f: json.dump(train_data, f) with open(val_file, 'w') as f: json.dump(val_data, f) print(f"Train annotations saved to: {train_file}") print(f"Validation annotations saved to: {val_file}")