Skip to content
Snippets Groups Projects
Commit 399c7962 authored by s87425's avatar s87425
Browse files

Finaler Finaler Stand

parent a7204068
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
EfficientNet.py
+ 45
− 2
View file @ 399c7962
...@@ -6,6 +6,9 @@ from torchvision import datasets, transforms ...@@ -6,6 +6,9 @@ from torchvision import datasets, transforms
from torchvision.models.resnet import resnet18, ResNet18_Weights from torchvision.models.resnet import resnet18, ResNet18_Weights
from torchvision.datasets import ImageFolder from torchvision.datasets import ImageFolder
from sklearn.metrics import confusion_matrix, classification_report from sklearn.metrics import confusion_matrix, classification_report
import sklearn
import numpy as np
import matplotlib.pyplot as plt
class LimitedImageFolder(Dataset): class LimitedImageFolder(Dataset):
def __init__(self, root, transform=None, limit_per_class=10000): def __init__(self, root, transform=None, limit_per_class=10000):
...@@ -63,7 +66,7 @@ img_transform = transforms.Compose([ ...@@ -63,7 +66,7 @@ img_transform = transforms.Compose([
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # Anpassung der Normalisierung für RGB transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # Anpassung der Normalisierung für RGB
]) ])
data_dir = 'Plant_leave_diseases_dataset_without_augmentation' # Setze das Verzeichnis deines Bild-Datasets hier ein data_dir = 'data1' # Setze das Verzeichnis deines Bild-Datasets hier ein
dataset = LimitedImageFolder(root=data_dir, transform=img_transform, limit_per_class=5) dataset = LimitedImageFolder(root=data_dir, transform=img_transform, limit_per_class=5)
train_size = int(0.8 * len(dataset)) train_size = int(0.8 * len(dataset))
...@@ -101,7 +104,7 @@ optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr ...@@ -101,7 +104,7 @@ optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr
criterion = nn.CrossEntropyLoss() criterion = nn.CrossEntropyLoss()
# Training # Training
num_epochs = 3 num_epochs = 30
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device) model.to(device)
...@@ -148,3 +151,43 @@ for epoch in range(num_epochs): ...@@ -148,3 +151,43 @@ for epoch in range(num_epochs):
# Speichern des trainierten Modells # Speichern des trainierten Modells
torch.save(model.state_dict(), 'efficientnet_finetuned.pth') torch.save(model.state_dict(), 'efficientnet_finetuned.pth')
def get_predictions(model, data_loader, device):
model.eval()
all_predictions = []
all_labels = []
with torch.no_grad():
for inputs, labels in data_loader:
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)
_, predictions = torch.max(outputs, 1)
all_predictions.extend(predictions.cpu().numpy())
all_labels.extend(labels.cpu().numpy())
return np.array(all_predictions), np.array(all_labels)
predictions, labels = get_predictions(model, test_loader, device)
cm = sklearn.metrics.confusion_matrix(labels, predictions)
ps = sklearn.metrics.precision_score(labels, predictions, average=None)
f1 = sklearn.metrics.f1_score(labels, predictions, average=None)
rc = sklearn.metrics.recall_score(labels, predictions, average=None)
print('confusion matrix:', cm , "\n \n",
'precision:', ps ,"\n \n",
'f1:', f1 , "\n \n",
'recall:', rc , "\n \n")
cmd = sklearn.metrics.ConfusionMatrixDisplay(cm, display_labels=["Apple_scab",
"Apple_Black_rot",
])
cmd.plot()
plt.show()
NN.py
+ 98
− 315
View file @ 399c7962
# import torch import torch
# import torch.nn as nn from torch import nn, optim
# import torch.optim as optim from torchvision import datasets, transforms, models
# import os from torch.utils.data import DataLoader, random_split
# from torchvision import datasets, transforms import sklearn
# from torch.utils.data import random_split from sklearn.metrics import accuracy_score
# import time from sklearn.metrics import confusion_matrix, classification_report
# import matplotlib.pyplot as plt import numpy as np
# import numpy as np
# import torch.utils.data
# class MyFCNN(nn.Module): import matplotlib.pyplot as plt
# def __init__(self, outputsize):
# super(MyFCNN, self).__init__()
# self.fc1 = nn.Linear(256*256, 4096) #65.536
# self.relu1 = nn.ReLU()
# self.fc2 = nn.Linear(4096, 256)
# self.relu2 = nn.ReLU()
# self.fc3 = nn.Linear(256, outputsize)
# self.softmax = nn.Softmax(dim=1)
# def forward(self, x):
# x = x.view(x.size(0), -1)
# print(x.size())
# x = self.fc1(x)
# x = self.relu1(x)
# x = self.fc2(x)
# x = self.relu2(x)
# x = self.fc3(x)
# x = self.softmax(x)
# return x
# def training(model, data_loader, optimizer, criterion, device):
# model.train()
# running_loss = 0.0
# running_corrects = 0
# for batch_idx, (inputs, labels) in enumerate(data_loader):
# # zero the parameter gradients
# optimizer.zero_grad()
# inputs = inputs.to(device)
# labels = labels.to(device)
# # forward
# outputs = model(inputs)
# loss = criterion(outputs, labels)
# _, preds = torch.max(outputs, 1) if __name__ == '__main__':
# Pfad zu den Daten
data_dir = 'data1' # Passe den Pfad zu deinem Datensatz an
# # backward # Definition von Daten-Transformationen
# loss.backward() data_transform = transforms.Compose([
# optimizer.step() transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# # statistics # Laden der Daten
# running_loss += loss.item() * inputs.size(0) image_dataset = datasets.ImageFolder(root=data_dir, transform=data_transform)
# running_corrects += torch.sum(preds == labels.data)
# if batch_idx % 10 == 0: # Aufteilung der Daten in Trainings-, Validierungs- und Testdaten
# print(f'Training Batch: {batch_idx:4} of {len(data_loader)}') train_size = int(0.8 * len(image_dataset))
val_size = test_size = (len(image_dataset) - train_size) // 2
# epoch_loss = running_loss / len(data_loader.dataset) train_dataset, val_dataset, labels = random_split(image_dataset, [train_size, val_size, test_size])
# epoch_acc = running_corrects.double() / len(data_loader.dataset)
# print('-' * 10) # Definition der DataLoaders
# print(f'Training Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}\n') train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=4, shuffle=False, num_workers=4)
# return epoch_loss, epoch_acc test_loader = DataLoader(labels, batch_size=4, shuffle=False, num_workers=4)
# def test(model, data_loader, criterion, device):
# model.eval()
# running_loss = 0.0
# running_corrects = 0
# # do not compute gradients
# with torch.no_grad():
# for batch_idx, (inputs, labels) in enumerate(data_loader):
# inputs = inputs.to(device)
# labels = labels.to(device)
# # forward
# outputs = model(inputs)
# loss = criterion(outputs, labels)
# _, preds = torch.max(outputs, 1)
# # statistics
# running_loss += loss.item() * inputs.size(0)
# running_corrects += torch.sum(preds == labels.data)
# if batch_idx % 10 == 0:
# print(f'Test Batch: {batch_idx:4} of {len(data_loader)}')
# epoch_loss = running_loss / len(data_loader.dataset)
# epoch_acc = running_corrects.double() / len(data_loader.dataset)
# print('-' * 10)
# print(f'Test Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}\n')
# return epoch_loss, epoch_acc # Verwendung eines vortrainierten ResNet-Modells
model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
# def plot(train_history, test_history, metric, num_epochs): # Anpassung des Klassifikationslayers für die Anzahl der Klassen in deinem Datensatz
num_classes = len(image_dataset.classes)
model.fc = nn.Linear(model.fc.in_features, num_classes)
# plt.title(f"Validation/Test {metric} vs. Number of Training Epochs") # Definition der Verlustfunktion und des Optimierers
# plt.xlabel(f"Training Epochs") criterion = nn.CrossEntropyLoss()
# plt.ylabel(f"Validation/Test {metric}") optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
# plt.plot(range(1, num_epochs + 1), train_history, label="Train")
# plt.plot(range(1, num_epochs + 1), test_history, label="Test")
# plt.ylim((0, 1.))
# plt.xticks(np.arange(1, num_epochs + 1, 1.0))
# plt.legend()
# plt.savefig(f"{metric}.png")
# plt.show()
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# torch.manual_seed(0)
# batch_size = 400 # Überprüfe, ob CUDA verfügbar ist, und weise das entsprechende Gerät zu
# num_epochs = 20 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# learning_rate = 0.0001 model.to(device)
# momentum = 0.9
# main_directory = 'Plant_leave_diseases_dataset_without_augmentation' # Training des Modells
# CATEGORIES = {} num_epochs = 3 # Anpassen der Anzahl der Epochen nach Bedarf
# # for idx, name in enumerate(range(len(os.listdir(main_directory)))):
# # ...
# for folderidx, foldername in enumerate(os.listdir(main_directory)): CATEGORIES[folderidx] = foldername for epoch in range(num_epochs):
for phase in ['train', 'val']:
if phase == 'train':
model.train()
data_loader = train_loader
else:
model.eval()
data_loader = val_loader if phase == 'val' else test_loader
# transform = transforms.Compose([ running_loss = 0.0
# transforms.Resize((256, 256)), running_corrects = 0
# transforms.ToTensor(),
# ])
# dataset = datasets.ImageFolder(root=main_directory, transform=transform) for inputs, labels in data_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
# train_size = int(0.9 * len(dataset)) with torch.set_grad_enabled(phase == 'train'):
# test_size = len(dataset) - train_size outputs = model(inputs)
loss = criterion(outputs, labels)
# # Split the dataset into training and test sets if phase == 'train':
# train_dataset, test_dataset = random_split(dataset, [train_size, test_size]) loss.backward()
optimizer.step()
# # Create data loaders _, predictions = torch.max(outputs, 1)
# train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True) running_loss += loss.item() * inputs.size(0)
# test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False) running_corrects += torch.sum(predictions == labels.data)
# # Initialize the model epoch_loss = running_loss / len(data_loader.dataset)
# output_size = len(CATEGORIES) epoch_acc = running_corrects.double() / len(data_loader.dataset)
# model = MyFCNN(outputsize=output_size).to(device)
# # Choose the loss function and optimization algorithm print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
# criterion = nn.CrossEntropyLoss()
# optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)
# # Lists to store training and test history for plotting
# train_loss_history = []
# train_acc_history = []
# test_loss_history = []
# test_acc_history = []
# # Training loop print("Training abgeschlossen.")
# for epoch in range(num_epochs):
# print(f'Epoch {epoch + 1}/{num_epochs}')
# # Training
# train_loss, train_acc = training(model, train_loader, optimizer, criterion, device)
# train_loss_history.append(train_loss)
# train_acc_history.append(train_acc)
# # Testing def get_predictions(model, data_loader, device):
# test_loss, test_acc = test(model, test_loader, criterion, device) model.eval()
# test_loss_history.append(test_loss) all_predictions = []
# test_acc_history.append(test_acc) all_labels = []
# # Plot the training and test history
# plot(train_loss_history, test_loss_history, 'Loss', num_epochs)
# plot(train_acc_history, test_acc_history, 'Accuracy', num_epochs)
# # # train_dataset, test_dataset = random_split(dataset, [train_size, test_size])
# # # train_dataset.dataset.transform = transform
# # # test_dataset.dataset.transform = transform
# # train_dataset, test_indices = random_split(dataset, [train_size, test_size])
# # # Manuelle Erstellung des Testdatensatzes
# # test_dataset = torch.utils.data.Subset(dataset, test_indices)
# # # Hier wird die ToTensor-Transformation für den Testdatensatz hinzugefügt
# # test_dataset.dataset.transform = transform
# # train_dataset.dataset.transform = transform
# # train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
# # test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
# # model = MyFCNN(outputsize=len(os.listdir(main_directory))).to(device)
# # optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)
# # criterion = nn.CrossEntropyLoss()
# # train_acc_history = []
# # test_acc_history = []
# # train_loss_history = []
# # test_loss_history = []
# # best_acc = 0.0
# # since = time.time()
# # for epoch in range(num_epochs):
# # print('Epoch {}/{}'.format(epoch, num_epochs - 1))
# # print('-' * 10)
# # # train
# # training_loss, training_acc = training(model, train_loader, optimizer,
# # criterion, device)
# # train_loss_history.append(training_loss)
# # train_acc_history.append(training_acc)
# # # test
# # test_loss, test_acc = test(model, test_loader, criterion, device)
# # test_loss_history.append(test_loss)
# # test_acc_history.append(test_acc)
# # # overall best model
# # if test_acc > best_acc:
# # best_acc = test_acc
# # # best_model_wts = copy.deepcopy(model.state_dict())
# # time_elapsed = time.time() - since
# # print(
# # f'Training complete in {(time_elapsed // 60):.0f}m {(time_elapsed % 60):.0f}s'
# # )
# # print(f'Best val Acc: {best_acc:4f}')
# # # plot loss and accuracy curves
# # train_acc_history = [h.cpu().numpy() for h in train_acc_history]
# # test_acc_history = [h.cpu().numpy() for h in test_acc_history]
# # plot(train_acc_history, test_acc_history, 'accuracy', num_epochs)
# # plot(train_loss_history, test_loss_history, 'loss', num_epochs)
# # # plot examples
# # example_data, _ = next(iter(test_dataset))
# # with torch.no_grad():
# # output = model(example_data.to(device))
# # for i in range(6):
# # plt.subplot(2, 3, i + 1)
# # plt.tight_layout()
# # plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
# # plt.title("Pred: {}".format(CATEGORIES[output.data.max(
# # 1, keepdim=True)[1][i].item()]))
# # plt.xticks([])
# # plt.yticks([])
# # plt.savefig("examples.png")
# # plt.show()
#'Plant_leave_diseases_dataset_without_augmentation'
import torch
from torch import nn, optim
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader, random_split
# Pfad zu den Daten
data_dir = 'Plant_leave_diseases_dataset_without_augmentation' # Passe den Pfad zu deinem Datensatz an
# Definition von Daten-Transformationen with torch.no_grad():
data_transform = transforms.Compose([ for inputs, labels in data_loader:
transforms.RandomResizedCrop(224), inputs = inputs.to(device)
transforms.RandomHorizontalFlip(), labels = labels.to(device)
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# Laden der Daten
image_dataset = datasets.ImageFolder(root=data_dir, transform=data_transform)
# Aufteilung der Daten in Trainings-, Validierungs- und Testdaten
train_size = int(0.8 * len(image_dataset))
val_size = test_size = (len(image_dataset) - train_size) // 2
train_dataset, val_dataset, test_dataset = random_split(image_dataset, [train_size, val_size, test_size])
# Definition der DataLoaders
train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=4, shuffle=False, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=4, shuffle=False, num_workers=4)
# Verwendung eines vortrainierten ResNet-Modells
model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
# Anpassung des Klassifikationslayers für die Anzahl der Klassen in deinem Datensatz
num_classes = len(image_dataset.classes)
model.fc = nn.Linear(model.fc.in_features, num_classes)
# Definition der Verlustfunktion und des Optimierers
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
# Überprüfe, ob CUDA verfügbar ist, und weise das entsprechende Gerät zu
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)
# Training des Modells
num_epochs = 5 # Anpassen der Anzahl der Epochen nach Bedarf
for epoch in range(num_epochs):
for phase in ['train', 'val']:
if phase == 'train':
model.train()
data_loader = train_loader
else:
model.eval()
data_loader = val_loader if phase == 'val' else test_loader
running_loss = 0.0
running_corrects = 0
for inputs, labels in data_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
with torch.set_grad_enabled(phase == 'train'):
outputs = model(inputs) outputs = model(inputs)
loss = criterion(outputs, labels) _, predictions = torch.max(outputs, 1)
all_predictions.extend(predictions.cpu().numpy())
all_labels.extend(labels.cpu().numpy())
return np.array(all_predictions), np.array(all_labels)
predictions, labels = get_predictions(model, test_loader, device)
cm = sklearn.metrics.confusion_matrix(labels, predictions)
ps = sklearn.metrics.precision_score(labels, predictions, average=None)
if phase == 'train': f1 = sklearn.metrics.f1_score(labels, predictions, average=None)
loss.backward()
optimizer.step()
_, preds = torch.max(outputs, 1) rc = sklearn.metrics.recall_score(labels, predictions, average=None)
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss / len(data_loader.dataset) print('confusion matrix:', cm , "\n \n",
epoch_acc = running_corrects.double() / len(data_loader.dataset) 'precision:', ps ,"\n \n",
'f1:', f1 , "\n \n",
'recall:', rc , "\n \n")
print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}') cmd = sklearn.metrics.ConfusionMatrixDisplay(cm, display_labels=["Apple_scab",
"Apple_Black_rot",
])
print("Training abgeschlossen.") cmd.plot()
plt.show()
autoencoder.py
+ 25
− 2
View file @ 399c7962
...@@ -8,6 +8,9 @@ from sklearn import svm ...@@ -8,6 +8,9 @@ from sklearn import svm
from sklearn.metrics import accuracy_score from sklearn.metrics import accuracy_score
from sklearn.utils.class_weight import compute_class_weight from sklearn.utils.class_weight import compute_class_weight
import numpy as np import numpy as np
import sklearn
import matplotlib.pyplot as plt
if not os.path.exists('./dc_img'): if not os.path.exists('./dc_img'):
os.mkdir('./dc_img') os.mkdir('./dc_img')
...@@ -58,7 +61,7 @@ img_transform = transforms.Compose([ ...@@ -58,7 +61,7 @@ img_transform = transforms.Compose([
]) ])
# Anpassung des Datasets auf ImageFolder # Anpassung des Datasets auf ImageFolder
data_dir = 'Plant_leave_diseases_dataset_without_augmentation' # Setze das Verzeichnis deines Bild-Datasets hier ein data_dir = 'data1' # Setze das Verzeichnis deines Bild-Datasets hier ein
dataset = LimitedImageFolder(root=data_dir, transform=img_transform, limit_per_class=10) dataset = LimitedImageFolder(root=data_dir, transform=img_transform, limit_per_class=10)
# Aufteilung in Trainings- und Testset # Aufteilung in Trainings- und Testset
...@@ -160,4 +163,24 @@ predicted_labels = svm_classifier.predict(test_latent) ...@@ -160,4 +163,24 @@ predicted_labels = svm_classifier.predict(test_latent)
# Berechne die Genauigkeit # Berechne die Genauigkeit
accuracy = accuracy_score(test_labels, predicted_labels) accuracy = accuracy_score(test_labels, predicted_labels)
print(f'SVM Accuracy: {accuracy}') print(f'SVM Accuracy: {accuracy}')
\ No newline at end of file
cm = sklearn.metrics.confusion_matrix(test_labels, predicted_labels)
ps = sklearn.metrics.precision_score(test_labels, predicted_labels, average=None)
f1 = sklearn.metrics.f1_score(test_labels, predicted_labels, average=None)
rc = sklearn.metrics.recall_score(test_labels, predicted_labels, average=None)
print('precision: {}'.format(ps))
print('recall: {}'.format(rc))
print('fscore: {}'.format(f1))
cmd = sklearn.metrics.ConfusionMatrixDisplay(cm, display_labels=["Apple_scab",
"Apple_Black_rot"
])
cmd.plot()
plt.show()
cnn.py
+ 412
− 410
View file @ 399c7962
This diff is collapsed.
create_descriptors.py
+ 29
− 14
View file @ 399c7962
...@@ -4,10 +4,12 @@ import numpy as np ...@@ -4,10 +4,12 @@ import numpy as np
"""This file computes feature vectors for every class.""" """This file computes feature vectors for every class."""
main_directory = "Plant_leave_diseases_dataset_without_augmentation" main_directory = "data1"
result_directory = 'result_descriptors_and_labels/' result_directory = 'result_descriptors_and_labels/'
label_counter = 0 label_counter = 0
nfeatures = 500
#sift = cv2.SIFT.create(nfeatures=500)
#Go through all directories in the main directory #Go through all directories in the main directory
for folder_name in os.listdir(main_directory): for folder_name in os.listdir(main_directory):
folder_path = os.path.join(main_directory, folder_name) folder_path = os.path.join(main_directory, folder_name)
...@@ -17,34 +19,47 @@ for folder_name in os.listdir(main_directory): ...@@ -17,34 +19,47 @@ for folder_name in os.listdir(main_directory):
#Calculate the number of pictures in the sub-directory #Calculate the number of pictures in the sub-directory
num_elements = len(os.listdir(folder_path)) num_elements = len(os.listdir(folder_path))
descriptor_matrix = np.zeros((num_elements, 2000*128)) descriptor_matrix = np.zeros((num_elements, nfeatures*128), dtype= np.float16)
label_vec = np.reshape(np.array([label_counter]*num_elements), (num_elements, 1)) label_vec = np.reshape(np.array([label_counter]*num_elements), (num_elements, 1))
for i in range(num_elements): for i in range(num_elements):
sift = cv2.SIFT.create() #Create a sift object for every single picture sift = cv2.SIFT.create(nfeatures=nfeatures-1) #Create a sift object for every single picture
#print("HALLO")
#Read pictures from the sub-directory #Read pictures from the sub-directory
img = cv2.imread(main_directory+"/"+folder_name+"/"+sorted(os.listdir(folder_path))[i]) img = cv2.imread(main_directory+"/"+folder_name+"/"+sorted(os.listdir(folder_path))[i])
#Save the descriptors of the picture in a list in the dictionary #Save the descriptors of the picture in a list in the dictionary
kp, des = sift.detectAndCompute(img, None) kp, des = sift.detectAndCompute(img, None)
#flatten_des = np.ravel(des)
#descriptor_matrix[i, 0:len(flatten_des)] = flatten_des
flatten_des = np.ravel(des) flatten_des = np.ravel(des)
descriptor_matrix[i, 0:len(flatten_des)] = flatten_des if len(flatten_des) < nfeatures * 128:
flatten_des = np.concatenate([flatten_des, np.zeros(nfeatures * 128 - len(flatten_des))])
elif len(flatten_des) > nfeatures * 128:
flatten_des = flatten_des[:nfeatures * 128]
descriptor_matrix[i, :len(flatten_des)] = flatten_des
print("HUHU")
num_rows_to_extract = int(np.floor(0.1 * descriptor_matrix.shape[0])) num_rows_to_extract = int(np.floor(0.1 * descriptor_matrix.shape[0]))
test_matrix= np.zeros((num_rows_to_extract, 2000*128)) test_matrix= np.zeros((num_rows_to_extract, nfeatures*128), dtype= np.float16)
test_matrix = descriptor_matrix[list(range(num_rows_to_extract)), :] test_matrix = descriptor_matrix[list(range(num_rows_to_extract)), :]
test_vec = np.zeros((num_rows_to_extract, 1)) test_vec = np.zeros((num_rows_to_extract, 1), dtype= np.float16 )
test_vec = label_vec[list(range(num_rows_to_extract)), :] test_vec = test_vec = label_vec[:num_rows_to_extract, :]
result_matrix = np.delete(descriptor_matrix, list(range(num_rows_to_extract)), axis=0) result_matrix = np.delete(descriptor_matrix, list(range(num_rows_to_extract)), axis=0)
result_vec = np.delete(label_vec, list(range(num_rows_to_extract)), axis=0) result_vec = np.delete(label_vec, list(range(num_rows_to_extract)), axis=0)
#Save every list in a separate npz, so the data of the classes is not shuffled #Save every list in a separate npz, so the data of the classes is not shuffled
np.savez(result_directory+'train/'+folder_name+'_sift_descriptors.npz', result_matrix) #shape: num_img, num_kp, len(descriptors); for 1 would be (360, 529, 128) print("Hallo1")
np.savez(result_directory+'train/'+folder_name+'_label_vector.npz', result_vec) result_matrix = np.nan_to_num(result_matrix)
np.savez(result_directory+'train/'+folder_name+'_sift_descriptors', result_matrix) #shape: num_img, num_kp, len(descriptors); for 1 would be (360, 529, 128)
np.savez(result_directory+'test/'+folder_name+'_sift_descriptors.npz', test_matrix) print("HAllo2")
np.savez(result_directory+'test/'+folder_name+'_label_vector.npz', test_vec) result_vec = np.nan_to_num(result_vec)
np.savez(result_directory+'train/'+folder_name+'_label_vector', result_vec)
test_matrix = np.nan_to_num(test_matrix)
np.savez(result_directory+'test/'+folder_name+'_sift_descriptors', test_matrix)
test_vec = np.nan_to_num(test_vec)
np.savez(result_directory+'test/'+folder_name+'_label_vector', test_vec)
label_counter += 1 label_counter += 1
#Delete this line if you want to compute the values for every class. Otherwise, you only compute #Delete this line if you want to compute the values for every class. Otherwise, you only compute
......
create_descriptors_new.py deleted 100644 → 0
+ 0
− 77
View file @ a7204068
import os
import cv2
import numpy as np
"""This file computes feature vectors for every class."""
main_directory = "Plant_leave_diseases_dataset_without_augmentation"
result_directory = 'result_descriptors_and_labels/'
label_counter = 0
nfeatures = 3
#sift = cv2.SIFT.create(nfeatures=500)
#Go through all directories in the main directory
for folder_name in os.listdir(main_directory):
folder_path = os.path.join(main_directory, folder_name)
#check if folder path leads to a folder
if os.path.isdir(folder_path):
#Calculate the number of pictures in the sub-directory
num_elements = len(os.listdir(folder_path))
descriptor_matrix = np.zeros((num_elements, nfeatures*128), dtype= np.float16)
label_vec = np.reshape(np.array([label_counter]*num_elements), (num_elements, 1))
for i in range(num_elements):
sift = cv2.SIFT.create(nfeatures=nfeatures-1) #Create a sift object for every single picture
#print("HALLO")
#Read pictures from the sub-directory
img = cv2.imread(main_directory+"/"+folder_name+"/"+sorted(os.listdir(folder_path))[i])
#Save the descriptors of the picture in a list in the dictionary
kp, des = sift.detectAndCompute(img, None)
#flatten_des = np.ravel(des)
#descriptor_matrix[i, 0:len(flatten_des)] = flatten_des
flatten_des = np.ravel(des)
if len(flatten_des) < nfeatures * 128:
flatten_des = np.concatenate([flatten_des, np.zeros(nfeatures * 128 - len(flatten_des))])
elif len(flatten_des) > nfeatures * 128:
flatten_des = flatten_des[:nfeatures * 128]
descriptor_matrix[i, :len(flatten_des)] = flatten_des
print("HUHU")
num_rows_to_extract = int(np.floor(0.1 * descriptor_matrix.shape[0]))
test_matrix= np.zeros((num_rows_to_extract, nfeatures*128), dtype= np.float16)
test_matrix = descriptor_matrix[list(range(num_rows_to_extract)), :]
test_vec = np.zeros((num_rows_to_extract, 1), dtype= np.float16 )
test_vec = test_vec = label_vec[:num_rows_to_extract, :]
result_matrix = np.delete(descriptor_matrix, list(range(num_rows_to_extract)), axis=0)
result_vec = np.delete(label_vec, list(range(num_rows_to_extract)), axis=0)
#Save every list in a separate npz, so the data of the classes is not shuffled
print("Hallo1")
result_matrix = np.nan_to_num(result_matrix)
np.savez(result_directory+'train/'+folder_name+'_sift_descriptors', result_matrix) #shape: num_img, num_kp, len(descriptors); for 1 would be (360, 529, 128)
print("HAllo2")
result_vec = np.nan_to_num(result_vec)
np.savez(result_directory+'train/'+folder_name+'_label_vector', result_vec)
test_matrix = np.nan_to_num(test_matrix)
np.savez(result_directory+'test/'+folder_name+'_sift_descriptors', test_matrix)
test_vec = np.nan_to_num(test_vec)
np.savez(result_directory+'test/'+folder_name+'_label_vector', test_vec)
label_counter += 1
#Delete this line if you want to compute the values for every class. Otherwise, you only compute
#the values for the first class
#For debugging:
'''loaded_data = np.load(result_directory+'Peach___healthy_sift_descriptors.npz')
# Zeige die Formen der Arrays an
for key, value in loaded_data.items():
print(f"Shape von {key}: {value.shape}") '''
#TODO : confusion Matrix, F1 score, precision und recall
\ No newline at end of file
plant_diseases_classifier_new.py → plant_diseases_classifier.py
+ 6
− 6
View file @ 399c7962
...@@ -8,7 +8,7 @@ import numpy as np ...@@ -8,7 +8,7 @@ import numpy as np
import sklearn import sklearn
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
nfeatures = 3 nfeatures = 500
main_directory = 'result_descriptors_and_labels/train' main_directory = 'result_descriptors_and_labels/train'
data_matrix = np.empty((0, 128*nfeatures), dtype = np.float16) data_matrix = np.empty((0, 128*nfeatures), dtype = np.float16)
label_vector = np.empty((0, 1), dtype = np.float16) label_vector = np.empty((0, 1), dtype = np.float16)
...@@ -51,16 +51,16 @@ for npz_name in sorted(os.listdir(test_directory)): ...@@ -51,16 +51,16 @@ for npz_name in sorted(os.listdir(test_directory)):
test_data_matrix = np.vstack((data_matrix, npz_arr),dtype = np.float16) test_data_matrix = np.vstack((data_matrix, npz_arr),dtype = np.float16)
test_classes = plant_diseases_svm.predict(test_data_matrix) test_classes = plant_diseases_svm.predict(test_data_matrix)
accuracy = accuracy_score(test_label_vector, test_data_matrix) accuracy = accuracy_score(test_label_vector, test_classes)
print(f'SVM Accuracy: {accuracy}') print(f'SVM Accuracy: {accuracy}')
cm = confusion_matrix(test_label_vector, test_data_matrix) cm = confusion_matrix(test_label_vector, test_classes)
ps = precision_score(test_label_vector, test_data_matrix, average=None) ps = precision_score(test_label_vector, test_classes, average=None)
f1 = f1_score(test_label_vector, test_data_matrix, average=None) f1 = f1_score(test_label_vector, test_classes, average=None)
rc = recall_score(test_label_vector, test_data_matrix, average=None) rc = recall_score(test_label_vector, test_classes, average=None)
print('confusion matrix:', cm , "\n \n", print('confusion matrix:', cm , "\n \n",
'precision:', ps ,"\n \n", 'precision:', ps ,"\n \n",
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment