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
from torchvision.models.resnet import resnet18, ResNet18_Weights
from torchvision.datasets import ImageFolder
from sklearn.metrics import confusion_matrix, classification_report
import sklearn
import numpy as np
import matplotlib.pyplot as plt
class LimitedImageFolder(Dataset):
def __init__(self, root, transform=None, limit_per_class=10000):
......@@ -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
])
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)
train_size = int(0.8 * len(dataset))
......@@ -101,7 +104,7 @@ optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr
criterion = nn.CrossEntropyLoss()
# Training
num_epochs = 3
num_epochs = 30
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
......@@ -148,3 +151,43 @@ for epoch in range(num_epochs):
# Speichern des trainierten Modells
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.nn as nn
# import torch.optim as optim
# import os
# from torchvision import datasets, transforms
# from torch.utils.data import random_split
# import time
# import matplotlib.pyplot as plt
# import numpy as np
# import torch.utils.data
import torch
from torch import nn, optim
from torchvision import datasets, transforms, models
from torch.utils.data import DataLoader, random_split
import sklearn
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix, classification_report
import numpy as np
# class MyFCNN(nn.Module):
# 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)
import matplotlib.pyplot as plt
# # 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
# loss.backward()
# optimizer.step()
# Definition von Daten-Transformationen
data_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# # statistics
# running_loss += loss.item() * inputs.size(0)
# running_corrects += torch.sum(preds == labels.data)
# Laden der Daten
image_dataset = datasets.ImageFolder(root=data_dir, transform=data_transform)
# if batch_idx % 10 == 0:
# print(f'Training 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)
# 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, labels = random_split(image_dataset, [train_size, val_size, test_size])
# print('-' * 10)
# print(f'Training Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}\n')
# return epoch_loss, epoch_acc
# 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')
# 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(labels, batch_size=4, shuffle=False, num_workers=4)
# 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")
# plt.xlabel(f"Training Epochs")
# plt.ylabel(f"Validation/Test {metric}")
# 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)
# Definition der Verlustfunktion und des Optimierers
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
# batch_size = 400
# num_epochs = 20
# learning_rate = 0.0001
# 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)
# main_directory = 'Plant_leave_diseases_dataset_without_augmentation'
# CATEGORIES = {}
# # for idx, name in enumerate(range(len(os.listdir(main_directory)))):
# # ...
# Training des Modells
num_epochs = 3 # Anpassen der Anzahl der Epochen nach Bedarf
# 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([
# transforms.Resize((256, 256)),
# transforms.ToTensor(),
# ])
running_loss = 0.0
running_corrects = 0
# 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))
# test_size = len(dataset) - train_size
with torch.set_grad_enabled(phase == 'train'):
outputs = model(inputs)
loss = criterion(outputs, labels)
# # Split the dataset into training and test sets
# train_dataset, test_dataset = random_split(dataset, [train_size, test_size])
if phase == 'train':
loss.backward()
optimizer.step()
# # Create data loaders
# 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)
_, predictions = torch.max(outputs, 1)
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(predictions == labels.data)
# # Initialize the model
# output_size = len(CATEGORIES)
# model = MyFCNN(outputsize=output_size).to(device)
epoch_loss = running_loss / len(data_loader.dataset)
epoch_acc = running_corrects.double() / len(data_loader.dataset)
# # Choose the loss function and optimization algorithm
# criterion = nn.CrossEntropyLoss()
# optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)
print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
# # Lists to store training and test history for plotting
# train_loss_history = []
# train_acc_history = []
# test_loss_history = []
# test_acc_history = []
# # Training loop
# 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)
print("Training abgeschlossen.")
# # Testing
# test_loss, test_acc = test(model, test_loader, criterion, device)
# test_loss_history.append(test_loss)
# test_acc_history.append(test_acc)
# # 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
def get_predictions(model, data_loader, device):
model.eval()
all_predictions = []
all_labels = []
# Definition von Daten-Transformationen
data_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
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'):
with torch.no_grad():
for inputs, labels in data_loader:
inputs = inputs.to(device)
labels = labels.to(device)
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':
loss.backward()
optimizer.step()
f1 = sklearn.metrics.f1_score(labels, predictions, average=None)
_, preds = torch.max(outputs, 1)
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
rc = sklearn.metrics.recall_score(labels, predictions, average=None)
epoch_loss = running_loss / len(data_loader.dataset)
epoch_acc = running_corrects.double() / len(data_loader.dataset)
print('confusion matrix:', cm , "\n \n",
'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
from sklearn.metrics import accuracy_score
from sklearn.utils.class_weight import compute_class_weight
import numpy as np
import sklearn
import matplotlib.pyplot as plt
if not os.path.exists('./dc_img'):
os.mkdir('./dc_img')
......@@ -58,7 +61,7 @@ img_transform = transforms.Compose([
])
# 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)
# Aufteilung in Trainings- und Testset
......@@ -160,4 +163,24 @@ predicted_labels = svm_classifier.predict(test_latent)
# Berechne die Genauigkeit
accuracy = accuracy_score(test_labels, predicted_labels)
print(f'SVM Accuracy: {accuracy}')
\ No newline at end of file
print(f'SVM Accuracy: {accuracy}')
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
"""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/'
label_counter = 0
nfeatures = 500
#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)
......@@ -17,34 +19,47 @@ for folder_name in os.listdir(main_directory):
#Calculate the number of pictures in the sub-directory
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))
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
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)
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]))
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_vec = np.zeros((num_rows_to_extract, 1))
test_vec = label_vec[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
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)
np.savez(result_directory+'train/'+folder_name+'_label_vector.npz', result_vec)
np.savez(result_directory+'test/'+folder_name+'_sift_descriptors.npz', test_matrix)
np.savez(result_directory+'test/'+folder_name+'_label_vector.npz', test_vec)
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
......
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
import sklearn
import matplotlib.pyplot as plt
nfeatures = 3
nfeatures = 500
main_directory = 'result_descriptors_and_labels/train'
data_matrix = np.empty((0, 128*nfeatures), 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)):
test_data_matrix = np.vstack((data_matrix, npz_arr),dtype = np.float16)
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}')
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",
'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