def image_recognition(image_path,save_path): image = utils.read_image(image_path) model = core.Model() labels, boxes, scores = model.predict_top(image) fig, ax = plt.subplots(1) # If the image is already a tensor, convert it back to a PILImage # and reverse normalize it if isinstance(image, torch.Tensor): image = reverse_normalize(image) image = transforms.ToPILImage()(image) ax.imshow(image) # Show a single box or multiple if provided if boxes.ndim == 1: boxes = boxes.view(1, 4) if labels is not None and not _is_iterable(labels): labels = [labels] # Plot each box for i in range(boxes.shape[0]): box = boxes[i] width, height = (box[2] - box[0]).item(), (box[3] - box[1]).item() initial_pos = (box[0].item(), box[1].item()) rect = patches.Rectangle(initial_pos, width, height, linewidth=1, edgecolor='r', facecolor='none') if labels: ax.text(box[0] + 5, box[1] - 5, '{}'.format(labels[i]), color='red') ax.add_patch(rect) plt.savefig(save_path)
def search(): btn['state'] = NORMAL #open image button is returened to enabled fracturedataset = core.Dataset( 'trainingimagesgui/' ) #initializes the dataset the parameter is the folder in which to get the images for the dataset mymodel = core.Model([ 'crack' ]) #calls the neural network and it is looking for boxes labelled crack print("model imported" ) #print function to see if the neural network has been called mymodel.fit(fracturedataset) #train the neuralnetwork on the dataset print("finished training custom dataset" ) #prints to show that the neural network has finished training #testing the neural network testimage = utils.read_image( filename ) #read the varible testimage which has the location of what is stored in variable filename print(filename) #test to see the correct location is being pulled endresult = mymodel.predict( testimage) #run the test image on the now trained neural network print( "prediction complete" ) #test to see that the test image has successfully ran on the neural network labels, boxes, scores = endresult #all the parameters the test image will have print(labels) #test to see if the correct label is printed print(boxes) #this will print the coordiantes of the boxes print(scores) #prints a score of how confident the neural network is visualize.show_labeled_image(testimage, boxes, labels) #display the image on the screen
def get_object_box(image, object_name): model = core.Model() labels, boxes, _ = model.predict_top(image) if object_name in labels: idx = labels.index(object_name) return boxes[idx] else: return None
def predict(img): model = core.Model() predictions = model.predict_top(img) labels, boxes, scores = predictions l = labels s = [] for i in scores: s.append(i.item()) result = {"labels": l, "scores": s} return result
def center_coordinates(self): model = core.Model() # print(model.predict_top(image)) # person_is_found = 0 try: labels, boxes, scores = model.predict_top(self.frame_input) min_x = 0 min_y = 0 max_x = 0 max_y = 0 for lbl, box in zip( labels, boxes): # zip stops when the shorter list is finished if lbl is "person": # print(type(box)) # finding the person's box a, b, c, d = box # a,b,c,d are "torch.Tensor" objects min_x = int(a) min_y = int(b) max_x = int(c) max_y = int(d) # print(min_x, min_y, max_x, max_y) # print("person HAS BEEN found") break except: # if no person has been found print("&&&&&&&&&&&& NO person found &&&&&&&&&&&&") return (0, 0), 0 # calculate main vector length, radius = (main vector length) * 0.2 radius = (((max_x - min_x)**2 + (max_y - min_y)**2)**0.5) * 0.2 radius = int(radius) # print(radius) center_x = int((max_x + min_x) / 2) center_y = int((max_y + min_y) / 2) # print(center_X, center_y) center_coordinates = (center_x, center_y) # visualize.show_labeled_image(image, boxes, labels) # CAN RETURN A CROPPED PERSON # img = cv2.imread(image_path) # crop_img = img[min_y:max_y, min_x:max_x] # cv2.imshow("cropped", crop_img) # cv2.waitKey(0) # return crop_img, center_coordinates cv2.circle(self.frame_output, center_coordinates, radius, (0, 0, 255), 10) return # center_coordinates, radius
def draw_boxes(original_image, new_image): model = core.Model() labels, boxes, scores = model.predict_top(original_image) # print(labels, boxes, scores) for i, box in enumerate(boxes): if scores[i] > 0.6: x, y, x_low, y_low = box w = x_low - x h = y_low - y cv2.rectangle(new_image, (int(x), int(y)), (int(x + w), int(y + h)), (255, 0, 0), 2) new_image = cv2.cvtColor(new_image, cv2.COLOR_BGR2RGB) return new_image
def trainMountingConfigClassifier(self, train_path, val_path, device=torch.device('cuda')): """ This function uses Faster R-CNN ResNet50 FPN as the base network and as a transfer learning framework to train a model that performs object detection on the mounting configuration of solar arrays. It uses the training data to locate and classify mounting configuration of the solar installation. It uses the validation data to prevent overfitting and to test the prediction on the fly. Parameters ----------- train_path: string This is the path to the folder that contains the training images Note that the directory must be structured in this format: train_path/ ...images/ ......a_image_1.png ......a_image_2.png ...annotations/ ......b_image_1.xml ......b_image_2.xml val_path: string This is the path to the folder that contains the validation images Note that the directory must be structured in this format: val_path/ ...images/ ......a_image_1.png ......a_image_2.png ...annotations/ ......b_image_1.xml ......b_image_2.xml device: string This argument is passed to the Model() class in Detecto. It determines how to run the model: either on GPU via Cuda (default setting), or on CPU. Please note that running the model on GPU results in significantly faster training times. Returns ----------- model: detecto.core.Model object The final trained mounting configuration object detection model. """ # Convert the data set combinations (png + xml) to a CSV record. val_labels_path = (val_path + '/annotations.csv') train_labels_path = (train_path + '/annotations.csv') utils.xml_to_csv(train_path + '/annotations/', train_labels_path) utils.xml_to_csv(val_path + '/annotations/', val_labels_path) # Custom oversampling to balance out our classes train_data = pd.read_csv(train_labels_path) class_count = pd.Series(train_data['class'].value_counts()) train_data_resampled = train_data.copy() for index, count in class_count.iteritems(): number_times_resample = class_count.max() - count # Randomly sample a class X times class_index_list = list( train_data[train_data['class'] == index].index) # Resample the list with with replacement idx_to_duplicate = choices(class_index_list, k=number_times_resample) for idx in idx_to_duplicate: dup = train_data.loc[idx] # Add to the dataframe train_data_resampled = \ train_data_resampled.append(dup, ignore_index=True) # Reindex after all of the duplicates have been added train_data_resampled = train_data_resampled.reset_index(drop=True) # Re-write the resampled data set train_data_resampled.to_csv(train_labels_path, index=False) custom_transforms = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(800), transforms.ToTensor(), utils.normalize_transform() ]) # Load in the training and validation data sets dataset = core.Dataset(train_labels_path, train_path + '/images', transform=custom_transforms) val_dataset = core.Dataset(val_labels_path, val_path + '/images') # Customize training options loader = core.DataLoader(dataset, batch_size=self.batch_size, shuffle=True) model = core.Model([ "ground-fixed", "carport-fixed", "rooftop-fixed", "ground-single_axis_tracker" ], device=device) losses = model.fit(loader, val_dataset, epochs=self.no_of_epochs, learning_rate=self.learning_rate, verbose=True) plt.plot(losses) plt.show() return model
labels2.append(labels[i]) if len(boxes2) == 0: boxes2 = boxes[i] else: boxes2 = torch.cat([boxes2,boxes[i]],-1) scores2.append(scores[i]) boxes2 = boxes2.view(-1, 4) return labels2, boxes2, scores2 from detecto import core, utils, visualize image = utils.read_image('../Label Fotos/COMBINED_DATA/IMG_012674.jpg') model = core.Model() labels, boxes, scores = model.predict_top(image) show_labeled_image(image, boxes, labels) from detecto import core, utils, visualize dataset = core.Dataset('/content/drive/My Drive/AEC Hackathon - LifeSavers/Label Fotos/COMBINED_DATA') print(len(dataset)) #model = core.Model(['person','helmet','nohelmet','nowest']) model = core.Model(['person']) model.fit(dataset) print("Training done")
from detecto import core, utils, visualize from torchvision import transforms augmentations = transforms.Compose([ transforms.ToPILImage(), transforms.RandomHorizontalFlip(0.5), transforms.ColorJitter(saturation=0.5), transforms.ToTensor(), utils.normalize_transform(), ]) val_dataset = core.Dataset('/dataset/validation_images/') dataset = core.Dataset('//dataset/train_images/', transform=augmentations) model = core.Model(['rust']) loader = core.DataLoader(dataset, batch_size=2, shuffle=True) losses = model.fit(loader, val_dataset, epochs=10, learning_rate=0.001, lr_step_size=5, verbose=True) model.save('model/model_weights.pth')
from detecto import core, utils, visualize dataset = core.Dataset('images/') model = core.Model(['fit_avocado', 'unfit_avocado']) model.fit(dataset) image = utils.read_image('images/10.jpg') predictions = model.predict(image) # predictions format: (labels, boxes, scores) labels, boxes, scores = predictions model.save('avocado_weights.pth')
import cv2 from detecto import core, utils, visualize import numpy as np dataset = core.Dataset( 'C:/Users/ABC/Desktop/New folder/TDAI/Data/sample') #load data print(len(dataset)) model = core.Model(['top_left', 'top_right', 'bottom_left', 'bottom_right']) #download model losses = model.fit(dataset, epochs=30, verbose=True, learning_rate=0.001) #set parameter formodel and fit model.save('id_card_4_conner.pth') frame = '' image = utils.read_image(frame) labels, boxes, score = model.predict(image) print(labels) print(boxes) ##draw boxes for i, box in enumerate(boxes): box = list(map(int, box)) x_min, y_min, x_max, y_max = box cv2.rectangle(image, (x_min, y_min), (x_max, y_max), (0, 255, 0), 2) cv2.putText(image, labels[i], (x_min, y_min), cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0)) #nonmax suppression
]) dataset = core.Dataset('labels/',transform=augmentations) model = core.Model(['baseball', 'beer', 'can_coke', 'can_pepsi', 'can_fanta', 'can_sprite', 'chips_can', 'coffee_box', 'cracker', 'cup', 'donut', 'fork', 'gelatin', 'meat', 'mustard', 'newspaper', 'orange', 'pear', 'plate', 'soccer_ball', 'soup', 'sponge', 'sugar', 'toy']) model.fit(dataset) print('Done training') # image = utils.read_image('labels/bottle.png') # predictions = model.predict(image)
# Getting all the train images path = 'images/' images = [] for file in os.listdir(path): if file.endswith(".png"): images.append(file) # In[6]: images # In[7]: # Testing out the pre-trained model to see if it detects anything in the screenshot image = utils.read_image(path + images[0]) model = core.Model() labels, boxes, scores = model.predict_top(image) visualize.show_labeled_image(image, boxes, labels) # The pre-trained model failed as expected. Though it did detect one of the tiles as a 'book'. # << Label screenshots with labelImg >> # In[10]: # Train model with custom labels dataset = core.Dataset(path) model = core.Model(['tile']) model.fit(dataset)
# prediction.setModelPath( "C:\\Users\\cw263\\OneDrive\\Desktop\\NSO_LIFE\\resnet50_weights_tf_dim_ordering_tf_kernels.h5") # prediction.loadModel() # predictions, percentage_probabilities = prediction.predictImage("C:\\Users\\cw263\\OneDrive\\Desktop\\image.jpg", result_count=5) # for index in range(len(predictions)): # print(predictions[index] , " : " , percentage_probabilities[index]) #import torch # from detecto import core, utils, visualize # image = utils.read_image('C:\\Users\\cw263\\OneDrive\\Desktop\\image.jpg') # model = core.Model() # labels, boxes, scores = model.predict_top(image) # visualize.show_labeled_image(image, boxes, labels) #print(torch.cuda.is_available()) from detecto import core, utils, visualize dataset = core.Dataset('images/') model = core.Model(['chris']) model.fit(dataset) image = utils.read_image('images/christopher.jpg') predictions = model.predict(image) labels, boxes, scores = predictions print(labels)
from detecto import core, utils, visualize dataset = core.Dataset('images/') model = core.Model(['un_logo']) model.fit(dataset) model.save('un_logo_model.pth')
def train(self): dataset = core.Dataset('images/') model = core.Model(['fit_avocado', 'unfit_avocado']) model.fit(dataset) self.model = model
from __future__ import print_function, division import pandas as pd import torch from detecto import core, utils, visualize import cv2 import datetime from urllib.request import urlopen import numpy as np device = torch.device("cuda") model = core.Model(['figure']) model.load('figure_model_weights_latest4.pth', ['figure']) index = ['color', 'color_name', 'hex', 'R', 'G', 'B'] df = pd.read_csv('colors.csv', names=index, header=None) fourcc = cv2.VideoWriter_fourcc(*'XVID') video_writer = cv2.VideoWriter('output.avi', fourcc, 20.0, (640, 480)) url = "http://192.168.43.42:80" CAMERA_BUFFER_SIZE = 4096 stream = urlopen(url + "/stream.jpg") bts = b'' while True: k = cv2.waitKey(1) bts += stream.read(CAMERA_BUFFER_SIZE) jpghead = bts.find(b'\xff\xd8') jpgend = bts.find(b'\xff\xd9') figure = 1 if jpghead > -1 and jpgend > -1: jpg = bts[jpghead:jpgend + 2] bts = bts[jpgend + 2:] frame = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_UNCHANGED) frame = cv2.resize(frame, (640, 480))
from detecto import core, utils, visualize dataset = core.Dataset('jpegs/') model = core.Model('Drone') model.fit(dataset)
def run_detect(image_name): image = utils.read_image('static/' + image_name) model = core.Model() labels, boxes, scores = model.predict_top(image) return visualize.show_labeled_image(image, boxes, labels)
def detecto_m(pic): image = utils.read_image(pic) model = core.Model() labels, boxes, scores = model.predict_top(image) result = visualize.show_labeled_image(image, boxes, labels) return result
from detecto import core, utils, visualize image = utils.read_image('cat.jpg') model = core.Model() labels, boxes, scores = model.predict_top(image) visualize.show_labeled_image(image, boxes, labels)
from detecto import core, utils, visualize import matplotlib.pyplot as plt dataset = core.Dataset('frames/') model = core.Model(['enemy']) model.fit(dataset, verbose=True) model.save('model.pth')