Технологии развиваются быстро. Тридцать лет назад, когда кто-то хотел написать одну научную работу, он должен был пойти в библиотеку и просмотреть сотни книг для справки. В настоящее время мы можем просто поискать в Интернете, чтобы найти эти документы. Невозможно нанять кого-то, кто будет вручную перепечатывать каждое слово с бумаги на компьютер, поэтому нам нужна технология, которая поможет нам решить проблему. Как новичок в области науки о данных, вы уже должны быть знакомы с SVM, деревом решений и KNN, я собираюсь показать вам продвинутый подход, представляющий собой комбинацию SVM, дерева решений и KNN, который представляет собой метод ансамбля. .
Во-первых, нам нужно прочитать набор данных. Здесь мы выбираем набор данных Kaggle, предоставленный Xai Nano. Мы будем считывать числовые данные только для демонстрации.
for each in numeric_data:
currentFolder = '245_data/' + each
for i, file in enumerate(os.listdir(currentFolder)):
После чтения изображений нам необходимо предварительно обработать данные. показано ниже:
for i, file in enumerate(os.listdir(currentFolder)):
if file_ct > 1000:
break
im= cv2.imread((os.path.join(currentFolder, file)))
img=cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
#resize
resized_image = cv2.resize(img, (16,16))
#normalization
img = np.array(resized_image)/255
img = img.ravel()
img = img.tolist()
data.append(img)
label.append(each)
file_ct+=1
numeric_df = pd.DataFrame(data)
numeric_df["label"] = label
Мы читаем только первые 1000 входных данных, потому что исходный набор данных огромен. Нам нужно преобразовать столбец меток в фиктивные переменные и разделить набор данных на учебные и тестовые цели.
Изображение предварительной обработки выглядит следующим образом:
Сначала мы обучаем данные, используя только простые модели, такие как SVM, линейная регрессия и наивный байесовский анализ. показатели точности - катастрофа. Отложив в сторону модель глубокого обучения, мы начинаем думать, что ансамбль может повысить результат.
Построить модель ансамбля очень просто, мы вызываем VotingClassifier из библиотеки sklearn и загружаем его оценками, сформированными с помощью KNN, дерева решений и SVM.
eclf1 = VotingClassifier(estimators=[('knn', KNN_classifier), ('DT', dt_classifier), ('svm', svm_classifier)], voting='hard')
eclf1 = eclf1.fit(X_train, y_train)
predict_start= time.time()
y_pred=eclf1.predict(X_test)
accuracy = accuracy_score(y_test,y_pred)*100
performance_result.append(['ensemble1',traning_time,predict_time,accuracy])
print(classification_report(y_test, y_pred))
Мы также можем рассмотреть KNN+SVM, который является популярным подходом в этой области. Алгоритм описан ниже:
1. Получить все классы с подсчетом из модели KNN
2. Упорядочить классы с подсчетом
3. Пройтись по парам классов от низкого количества до высокого количества< br /> 4. Для каждой пары выберите соответствующий SVM и сохраните класс с наибольшей достоверностью
5. Используйте выбранный класс после цикла в качестве окончательной предикации
Просто код выглядит так
Сначала определяем K-Nearest-Neighbor:
for n_neighbors in range(1, 15):
print(f'n_neighbors: {n_neighbors}')
distances, indices = knn.kneighbors(X_test, n_neighbors=n_neighbors)
y_pred = []
for i, index in enumerate(tqdm(indices)):
from collections import Counter
c = Counter(map(lambda x: y_train[x], index))
mc = c.most_common(3)
if len(mc) == 1:
y_pred.append(mc[0][0])
elif len(mc) == 2:
c0, c1 = mc[0][0], mc[1][0]
svm = get_svm(c0, c1)
p = svm.predict(X_test[i].reshape(1, -1))
y_pred.append(classes[c0][c1][p].item())
else:
c0, c1, c2 = mc[0][0], mc[1][0], mc[2][0]
svm = get_svm(c1, c2)
p = svm.predict(X_test[i].reshape(1, -1))
c12 = classes[c1][c2][p].item()
svm = get_svm(c0, c12)
p = svm.predict(X_test[i].reshape(1, -1))
y_pred.append(classes[c0][c12][p].item())
accuracy = accuracy_score(y_test, y_pred)*100
print(f'accuracy: {accuracy}')
Затем
def transform_X(X, y, n_neighbors):
# neigh_dist, neigh_ind
distances, indices = knn.kneighbors(X, n_neighbors=n_neighbors)
votes = y[indices]
X_transform = []
for distance, vote in zip(distances, votes):
d = [0 for _ in range(n_classes)]
c = [0 for _ in range(n_classes)]
for dd, v in zip(distance, vote):
c[v] += 1
d[v] += dd
X_transform.append(np.array(d))
return np.vstack(X_transform)
for n_neighbors in [5, 10, 15, 20]:
X_test_svm = transform_X(X_test, y_train, n_neighbors)
for max_iter in [500, 1000, 2000]:
for kernel in ["SVC", "LinearSVC"]:
print(f'max_iter: {max_iter}, kernel: {kernel}, training SVM')
train_start = dt.now()
if kernel == "LinearSVC":
svm = make_pipeline(StandardScaler(), LinearSVC(max_iter=max_iter, tol=1e-5))
else:
svm = make_pipeline(StandardScaler(), SVC(max_iter=max_iter, tol=1e-5))
svm.fit(X_train_svm, y_train)
traing_time = (train_start.now() - train_start).seconds
print(f'traing_time: {traing_time}')
score_start = dt.now()
accuracy = svm.score(X_test_svm, y_test)
score_time = (score_start.now() - score_start).seconds
print(f'accuracy: {accuracy}, time: {score_time}')
Отчет о классификации и оценка точности распечатываются для дальнейшей оценки. А пока вы можете поиграть с параметром VotingClassifier, чтобы увидеть, сможете ли вы улучшить производительность модели еще лучше.
Из таблицы результатов эксперимента «Производительность модели» мы видим, что точность для всех моделей не идеальна, где самый высокий уровень точности составляет всего 76,35% по дереву решений, а самый низкий — 19,83% по случайному лесу. Время обучения чрезвычайно велико в SVM и ансамбле, оба составляют более 800 000 секунд, но наивный байесовский алгоритм, дерево решений и случайный лес составляют менее 6 секунд. Gradient Descent также показал хорошие результаты с точки зрения времени обучения модели — 10,39 секунды.
Все ансамблевые методы имеют самые высокие баллы запоминания по сравнению с другими: самый высокий показатель — 85%, а самый низкий — 68%. KNN получил самый низкий показатель отзыва с 45%.
Вот и все, что касается построения методом ансамбля, он достаточно прост и эффективен. Однако на подготовку и прогнозирование результатов ушло очень много времени. Учитывайте плюсы и минусы при создании собственного ансамблевого метода.
