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 train(model_name, class_names, load_model_nr, epochs, callback=None): train_dataset = core.Dataset(op.join(dataset_path, model_name, 'train')) val_dataset = core.Dataset(op.join(dataset_path, model_name, 'validate')) save_dir = op.join(result_dir, model_name) print("Training set: {}".format(len(train_dataset))) print("Validation set: {}".format(len(val_dataset))) if not os.path.exists(save_dir): os.mkdir(save_dir) model = core.Model.load( op.join(save_dir, 'model_{}.pth'.format(load_model_nr)), class_names) model.fit(train_dataset, val_dataset, save_path=save_dir, start_epoch=load_model_nr, epochs=load_model_nr + epochs, verbose=True, callback=callback) return model
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')
# train.py # Import detecto libs, the lib is great and does all the work # https://github.com/alankbi/detecto from detecto import core from detecto.core import Model # Load all images and XML files from the Classification section dataset = core.Dataset('images_classified/') # We initalize the Model and map it to the label we used in labelImg classification model = Model(['aboriginal_flag']) # The model.fit() method is the bulk of this program # It starts training your model synchronously (the lib doesn't expose many logs) # It will take up quite a lot of resources, and if it crashes on your computer # you will probably have to rent a bigger box for a few hours to get this to run on. # Epochs essentially means iterations, the more the merrier (accuracy) (up to a limit) # It will take quite a while for this process to end, grab a wine. model.fit(dataset, epochs=10, verbose=True) # TIP: The more images you classify and the more epochs you run, the better your results will be. # Once the model training has finished, we can save to a single file. # Passs this file around to anywhere you want to now use your newly trained model. model.save('model.pth') # If you have got this far, you've already trained your very own unique machine learning model # What are you going to do with this new found power?
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
def train(self): dataset = core.Dataset('images/') model = core.Model(['fit_avocado', 'unfit_avocado']) model.fit(dataset) self.model = model
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')
from detecto import core, utils, visualize dataset = core.Dataset('jpegs/') model = core.Model('Drone') model.fit(dataset)
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
sys.path.remove('/opt/ros/kinetic/lib/python2.7/dist-packages') <<<<<<< HEAD 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(), ]) 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',
# 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) # In[5]: # Getting all the test images path = 'images/test/' images = [] for file in os.listdir(path): if file.endswith(".png"): images.append(file) images # In[6]:
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") #model = core.Model.load('safetyheroes_model_v3.pth', ['person']) #print("loaded")
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')