Найкращі ІДЕЇ (Міжнародний симпозіум з інженерних додатків баз даних) грудень 2024, використовуючи Java

Редаговано Пітером З. Ревезом

для Information | An Open Access Journal from MDPI

Спеціальний випуск Міжнародного симпозіуму з інженерії баз даних

Спеціальний випуск Міжнародного симпозіуму з інженерії баз даних

Стаття під назвою "Best IDEAS: Спеціальний випуск Міжнародного симпозіуму з інженерії баз даних" була опублікована в журналі Information (Том 15, Номер 11) у листопаді 2024 року.

Цей спеціальний випуск об'єднує вибрані статті з Міжнародного симпозіуму з інженерії баз даних (IDEAS), конференції, присвяченої дослідженню та розвитку технологій баз даних і їх застосувань.

Симпозіум служить платформою для дослідників, практиків і академіків для представлення своїх результатів, обміну ідеями та обговорення останніх тенденцій у галузі інженерії баз даних.

Спеціальний випуск охоплює широкий спектр тем в межах інженерії застосувань баз даних.

Ці теми включають, але не обмежуються, видобутком даних, аналітикою великих даних, безпекою баз даних, хмарними обчисленнями та інтеграцією штучного інтелекту з системами баз даних.

Кожна стаття сприяє розумінню та розвитку технологій баз даних, зокрема теоретичних і практичних аспектів.

Публікація цього спеціального випуску підкреслює важливість інженерії баз даних у сучасному цифровому середовищі.

Оскільки обсяг даних продовжує зростати в різних секторах, потреба в ефективних, безпечних і масштабованих рішеннях для баз даних стає все більш критичною.

Дослідження, представлені в цьому випуску, не лише відображають сучасні досягнення, але й прокладають шлях для майбутніх інновацій у галузі.

Підсумовуючи, спеціальний випуск "Best IDEAS" пропонує всебічний огляд передових досліджень у галузі інженерії застосувань баз даних, висвітлюючи постійний розвиток та важливість технологій баз даних для вирішення складних завдань управління даними.

Основні проблеми досліджень для систем безперервних розподілених обчислень

Основні проблеми досліджень для систем безперервних розподілених обчислень

Стаття під назвою "Основні проблеми досліджень для систем безперервних розподілених обчислень", опублікована в журналі Information в березні 2023 року, розглядає новий парадигму систем безперервних розподілених обчислень (DCCS). Ця парадигма інтегрує хмарні та крайові обчислення для створення єдиного та динамічного середовища обчислень. Автори визначають чотири ключові напрямки, які потребують комплексного вивчення для розвитку DCCS: представлення системи, моделювання, навчання протягом усього життя та бізнес-моделі.

Представлення системи

Традиційні статичні архітектури є недостатніми для динамічного та гетерогенного характеру DCCS. Автори пропонують нові методи представлення, які здатні враховувати мінливість цих систем. Вони пропонують використання концепції Маркова покривала (Markov Blanket) з баєсівської статистики, яка визначає набір змінних, що впливають на цільову змінну. Цей підхід дозволяє створювати масштабовані та гнучкі представлення, що дозволяють системі адаптуватися до змін у її середовищі та взаємодіях.

Моделювання системи

Моделювання DCCS стикається з труднощами через їх розподілений характер та невизначеність. Автори підкреслюють необхідність моделей, які можуть бути розподілені між різними компонентами системи та здатні справлятися з непередбачуваністю, як у поведінці користувачів, так і в інфраструктурі. Вони пропонують застосовувати ймовірнісні моделі та використовувати концепції, такі як активне передбачення (active inference), для управління динамічною поведінкою DCCS.

Навчання протягом усього життя

DCCS повинні мати можливість постійно вчитися та адаптуватися протягом всього життєвого циклу їхнього функціонування.
Автори обговорюють інтеграцію рамок навчання протягом усього життя (lifelong learning), які дозволяють системам еволюціонувати разом з новими даними та досвідом. Ця безперервна адаптація є важливою для підтримки актуальності та ефективності системи в умовах змінюваних навантажень і змін навколишнього середовища. Вони підкреслюють важливість самонавчальних систем, які використовують техніки машинного навчання (machine learning) для досягнення цієї мети. ACM Digital Library

Бізнес-моделі

Успіх DCCS залежить не лише від технічних досягнень, але й від життєздатних бізнес-моделей. Автори зазначають складнощі, що виникають через інфраструктури з багатьма орендарями та власниками, які вимагають співпраці та гнучких бізнес-стратегій. Вони наводять ініціативи, як-от GSMA Open Gateway, який надає API для розробників додатків для налаштування мереж під конкретні потреби, як кроки до розвитку такої співпраці.

Підсумовуючи, стаття підкреслює необхідність комплексного та міждисциплінарного підходу для вирішення основних проблем у розробці систем безперервних розподілених обчислень. Сфокусувавшись на інноваційних представленнях систем, надійних методах моделювання, безперервних можливостях навчання та стійких бізнес-моделях, дослідження закладає основу для еволюції наступного покоління середовищ розподілених обчислень.

1. Представлення системи з використанням Маркових покривал

Стаття пропонує використовувати Маркові покривала для представлення компонентів системи та їхніх взаємодій. У Java це можна змоделювати за допомогою класів і структур даних для представлення вузлів і їхніх залежностей.

import java.util.*;  

class Node {  
 String name;  
 List markovBlanket;  

 Node(String name) {  
 this.name = name;  
 this.markovBlanket = new ArrayList<>();  
 }  

 void addDependency(Node node) {  
 markovBlanket.add(node);  
 }  

 List getMarkovBlanket() {  
 return markovBlanket;  
 }  
}  

public class MarkovBlanketExample {  
 public static void main(String[] args) {  
 Node nodeA = new Node("A");  
 Node nodeB = new Node("B");  
 Node nodeC = new Node("C");  

 nodeA.addDependency(nodeB);  
 nodeA.addDependency(nodeC);  

 System.out.println("Маркове покривало вузла A:");  
 for (Node node : nodeA.getMarkovBlanket()) {  
 System.out.println(node.name);  
 }  
 }  
}

2. Моделювання динамічної поведінки за допомогою патерну Спостерігач (Observer Pattern)

Для обробки динамічної поведінки в розподілених системах можна застосувати патерн Спостерігач (Observer pattern). Цей патерн дозволяє об'єктам отримувати повідомлення про зміни стану в інших об'єктах.

import java.util.*;  

interface Observer {  
 void update(String message);  
}  

class Component implements Observer {  
 String name;  

 Component(String name) {  
 this.name = name;  
 }  

 @Override  
 public void update(String message) {  
 System.out.println(name + " отримав оновлення: " + message);  
 }  
}  

class SystemModel {  
 List observers = new ArrayList<>();  

 void addObserver(Observer observer) {  
 observers.add(observer);  
 }  

 void notifyObservers(String message) {  
 for (Observer observer : observers) {  
 observer.update(message);  
 }  
 }  
}  

public class ObserverPatternExample {  
 public static void main(String[] args) {  
 Component comp1 = new Component("Компонент 1");  
 Component comp2 = new Component("Компонент 2");  

 SystemModel system = new SystemModel();  
 system.addObserver(comp1);  
 system.addObserver(comp2);  

 system.notifyObservers("Змінився стан системи.");  
 }  
}

3. Навчання протягом усього життя за допомогою простого адаптивного системи

Впровадження навчання протягом усього життя передбачає створення систем, які адаптуються з часом.
Нижче наведено спрощений приклад адаптивної системи, яка коригує свою поведінку залежно від введених даних.

class AdaptiveSystem {  
 int state = 0;  

 void receiveInput(int input) {  
 // Проста логіка адаптації  
 state += input;  
 System.out.println("Стан системи оновлено до: " + state);  
 }  
}  

public class LifelongLearningExample {  
 public static void main(String[] args) {  
 AdaptiveSystem system = new AdaptiveSystem();  
 system.receiveInput(5);  
 system.receiveInput(-2);  
 }  
}

Порівняльний аналіз атак на визначення приналежності в федеративному та централізованому навчанні

Порівняльний аналіз атак на визначення приналежності в федеративному та централізованому навчанні

Стаття під назвою "Порівняльний аналіз атак на визначення приналежності в федеративному та централізованому навчанні", опублікована в журналі Information в листопаді 2023 року, досліджує сприйнятливість моделей машинного навчання до атак на визначення приналежності (Membership Inference Attacks, MIA) як у федеративному, так і в централізованому навчанні.

Атаки на визначення приналежності

MIA спрямовані на визначення того, чи був конкретний запис даних частиною навчального набору даних моделі. Такі атаки становлять значний ризик для конфіденційності, особливо коли моделі тренуються на чутливій інформації. Розуміння динаміки MIA є важливим для розробки надійних засобів захисту, щоб захистити конфіденційність осіб.

Федеративне та централізоване навчання

У централізованому навчанні дані агрегуються в одному сховищі для навчання моделі. У контексті федеративного навчання кілька сторін можуть спільно тренувати модель без обміну даними, що нібито покращує конфіденційність. Однак дослідження показало, що моделі федеративного навчання не є за замовчуванням захищеними від MIA, і ризик існує в обох підходах до навчання.

Методологія

Дослідники провели емпіричні оцінки, використовуючи різні оптимізатори, та оцінили ефективність MIA з застосуванням та без застосування захисних заходів на зображеннях та табличних наборах даних. Такий комплексний підхід дозволив отримати більш глибоке розуміння того, як різні фактори впливають на успішність атак у різних середовищах навчання.

Висновки

Дослідження виявило, що комбінація знань дистиляції з традиційними методами пом'якшення — такими як гаусівський відсів (Gaussian dropout), гаусівський шум (Gaussian noise) та регуляризація активності (activity regularization) — значно знижує ризик витоку інформації як у федеративному, так і в централізованому навчанні. Ці комбіновані засоби захисту підвищують стійкість моделі до MIA без суттєвих втрат у продуктивності.

Наслідки

Отримані результати підкреслюють необхідність впровадження надійних механізмів захисту в моделях машинного навчання, незалежно від середовища навчання. Оскільки федеративне навчання набирає популярності завдяки своєму потенціалу для збереження конфіденційності, необхідно визнати та усунути його вразливості для забезпечення комплексного захисту даних.

Підсумовуючи, стаття надає цінні відомості щодо порівняльних вразливостей моделей федеративного та централізованого навчання до атак на визначення приналежності. Вона висвітлює ефективні стратегії захисту, сприяючи подальшим зусиллям щодо покращення конфіденційності та безпеки в застосуваннях машинного навчання.

MIA спрямовані на визначення того, чи був конкретний запис даних частиною навчального набору даних моделі, що може порушити конфіденційність даних.
Дослідження оцінює різні методології атак і механізми захисту на різних наборах даних та оптимізаторах.

Концептуальний огляд:

Тренування цільової моделі:

• Тренування моделі машинного навчання (наприклад, нейронної мережі) на наборі даних.

Створення моделі атаки:

• Розробка моделі атаки, яка намагається визначити, чи був конкретний запис даних частиною навчального набору цільової моделі.

Оцінка атаки:

• Тестування точності моделі атаки при визначенні статусу приналежності.

Спрощений приклад на Java:

Реалізація повноцінної моделі машинного навчання та атаки на визначення приналежності на Java вимагає значного обсягу коду та використання спеціалізованих бібліотек. Однак ось дуже спрощений приклад для демонстрації концепції:

import java.util.HashSet;  
import java.util.Set;  

public class MembershipInferenceDemo {  
 public static void main(String[] args) {  
 // Моделювання навчального набору даних  
 Set trainingData = new HashSet<>();  
 trainingData.add("data_point_1");  
 trainingData.add("data_point_2");  
 trainingData.add("data_point_3");  

 // Моделювання передбачення цільової моделі  
 String inputData = "data_point_2";  
 boolean modelPrediction = targetModelPredict(inputData);  

 // Атака на визначення приналежності  
 boolean isMember = membershipInferenceAttack(inputData, modelPrediction, trainingData);  
 System.out.println("Чи є вхідні дані частиною навчального набору? " + isMember);  
 }  

 // Моделювання функції передбачення цільової моделі  
 public static boolean targetModelPredict(String data) {  
 // Місце для логіки передбачення моделі  
 return data.hashCode() % 2 == 0; // Тестова умова  
 }  

 // Спрощена функція атаки на визначення приналежності  
 public static boolean membershipInferenceAttack(String data, boolean modelPrediction, Set trainingData) {  
 // У реальному випадку атака аналізувала б результати роботи моделі  
 // Тут ми просто перевіряємо, чи є дані в навчальному наборі  
 return trainingData.contains(data);  
 }  
}

Цей приклад є елементарною ілюстрацією і не охоплює всі складнощі, які виникають при реальних атаках на визначення приналежності або захистах від них у моделях машинного навчання. Реалізація реалістичних сценаріїв вимагала б використання комплексних фреймворків для машинного навчання та глибшого розуміння методологій атак, як це обговорюється в згаданій статті.

Дослідження тенденцій федеративного навчання за допомогою підходу семантичного кластеризування ключових слів

Дослідження тенденцій федеративного навчання за допомогою підходу семантичного кластеризування ключових слів

Стаття під назвою "Дослідження тенденцій федеративного навчання за допомогою підходу семантичного кластеризування ключових слів", опублікована в журналі Information в липні 2024 року, представляє інноваційний метод аналізу дослідницьких тенденцій у сфері федеративного навчання (Federated Learning, FL) через автоматичне семантичне кластеризування ключових слів. MDPI

Фон

Федеративне навчання стало трансформаційною парадигмою в колективному машинному навчанні, що дозволяє кільком пристроям або установам спільно тренувати моделі, зберігаючи конфіденційність даних. На відміну від традиційних централізованих методів, FL зберігає сирі дані на окремих пристроях, обмінюючись лише оновленнями моделі. Швидке розширення досліджень у сфері FL створює проблеми з визначенням поточних тенденцій та нових підгалузей в цій сфері. Традиційні ручні огляди літератури стають непрактичними через експоненціальне зростання публікацій.

Методологія

Для вирішення цієї проблеми автори зібрали набір даних з 7 953 наукових статей про FL з бази даних Scopus та витягли ключові слова, що представляють ландшафт досліджень у сфері FL. Вони використовували техніки обробки природної мови (Natural Language Processing, NLP), зокрема попередньо навчану модель трансформера, щоб перетворити ключові слова на векторні вбудовування, що захоплюють їх семантичні зв'язки.
Далі було застосовано агломеративне кластеризування для визначення основних тематичних тенденцій та підгалузей у федеративному навчанні (Federated Learning, FL). MDPI

Висновки

Дослідження надає детальний огляд тематичного ландшафту FL, розділяючи ключові напрями на теоретичні аспекти та практичні застосування. Цей підхід, заснований на даних, виходить за межі традиційних оглядів літератури, пропонуючи всеохоплюючий огляд поточної еволюції FL. Автори зробили свій набір даних по FL та результати кластеризування ключових слів доступними для публічного використання, що сприяє подальшим дослідженням та аналізу. MDPI

Наслідки

Використовуючи автоматизоване семантичне кластеризування ключових слів, дослідження пропонує масштабований та ефективний метод для аналізу великих обсягів наукової літератури. Цей підхід дозволяє дослідникам виявляти нові тенденції, розуміти тематичну структуру галузі та приймати обґрунтовані рішення щодо майбутніх напрямків досліджень.

У підсумку стаття представляє новий та ефективний підхід до дослідження тенденцій федеративного навчання, надаючи цінні відомості про швидко змінюваний ландшафт досліджень FL.

Огляд:

Семантичне кластеризування ключових слів передбачає групування ключових слів на основі їх значення. Цей процес зазвичай включає:

1. Збір ключових слів: Збір списку ключових слів з наукових статей або інших джерел.
2. Генерація вбудовувань: Перетворення ключових слів у числові вектори, що відображають їх семантичне значення.
3. Кластеризування: Застосування алгоритмів кластеризації для групування схожих векторів ключових слів.

Реалізація на Java:

Реалізація цього підходу на Java вимагає кількох етапів. Ми використаємо бібліотеку Deeplearning4j для обробки вбудовувань слів та кластеризації.

1. Налаштування:

Переконайтеся, що ви додали наступні залежності у ваш pom.xml, якщо використовуєте Maven:

 org.deeplearning4j  
 deeplearning4j-core  
 1.0.0-M1.1  



 org.nd4j  
 nd4j-native-platform  
 1.0.0-M1.1  



 org.slf4j  
 slf4j-api  
 1.7.30  



 org.slf4j  
 slf4j-simple  
 1.7.30  

2. Завантаження попередньо навчальних векторів слів:

Ми використаємо попередньо навчальні вектори слів, такі як Word2Vec. Ви можете завантажити попередньо навчану модель або навчити свою власну.

import org.deeplearning4j.models.embeddings.loader.WordVectorSerializer;  
import org.deeplearning4j.models.word2vec.Word2Vec;  

import java.io.File;  
import java.io.IOException;  

public class WordVectorLoader {  
 public static Word2Vec loadModel(String filePath) throws IOException {  
 return WordVectorSerializer.readWord2VecModel(new File(filePath));  
 }  
}

3. Генерація вбудовувань для ключових слів:

import org.deeplearning4j.models.word2vec.Word2Vec;  
import org.nd4j.linalg.api.ndarray.INDArray;  

import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  

public class KeywordEmbeddingGenerator {  
 private Word2Vec word2Vec;  

 public KeywordEmbeddingGenerator(Word2Vec word2Vec) {  
 this.word2Vec = word2Vec;  
 }  

 public Map generateEmbeddings(List keywords) {  
 Map embeddings = new HashMap<>();  
 for (String keyword : keywords) {  
 if (word2Vec.hasWord(keyword)) {  
 embeddings.put(keyword, word2Vec.getWordVectorMatrix(keyword));  
 }  
 }  
 return embeddings;  
 }  
}

4.

Кластеризація ключових слів:

Ми використаємо кластеризацію K-Means для групування векторів вбудовувань ключових слів.

import org.deeplearning4j.clustering.cluster.Cluster;  
import org.deeplearning4j.clustering.cluster.ClusterSet;  
import org.deeplearning4j.clustering.kmeans.KMeansClustering;  
import org.deeplearning4j.clustering.vptree.VPTree;  
import org.nd4j.linalg.api.ndarray.INDArray;  

import java.util.List;  
import java.util.Map;  

public class KeywordClustering {  
 public static ClusterSet clusterKeywords(Map embeddings, int numClusters) {  
 KMeansClustering kMeansClustering = KMeansClustering.setup(numClusters, 100, "cosinesimilarity");  
 return kMeansClustering.applyTo(new VPTree<>(embeddings));  
 }  

 public static void printClusters(ClusterSet clusterSet) {  
 List clusters = clusterSet.getClusters();  
 for (int i = 0; i < clusters.size(); i++) {  
 System.out.println("Cluster " + i + ": " + clusters.get(i).getPoints());  
 }  
 }  
}

5. Головний додаток:

import org.deeplearning4j.models.word2vec.Word2Vec;  
import org.deeplearning4j.clustering.cluster.ClusterSet;  
import org.nd4j.linalg.api.ndarray.INDArray;  

import java.io.IOException;  
import java.util.Arrays;  
import java.util.List;  
import java.util.Map;  

public class SemanticKeywordClusteringApp {  
 public static void main(String[] args) {  
 try {  
 // Завантаження попередньо навченої моделі Word2Vec  
 Word2Vec word2Vec = WordVectorLoader.loadModel("path_to_pretrained_model");  

 // Список ключових слів  
 List keywords = Arrays.asList("federated learning", "machine learning", "data privacy", "neural networks");  

 // Генерація вбудовувань  
 KeywordEmbeddingGenerator embeddingGenerator = new KeywordEmbeddingGenerator(word2Vec);  
 Map embeddings = embeddingGenerator.generateEmbeddings(keywords);  

 // Кластеризація ключових слів  
 int numClusters = 2; // Встановіть бажану кількість кластерів  
 ClusterSet clusterSet = KeywordClustering.clusterKeywords(embeddings, numClusters);  

 // Виведення кластерів  
 KeywordClustering.printClusters(clusterSet);  
 } catch (IOException e) {  
 e.printStackTrace();  
 }  
 }  
}

• Попередньо навчена модель: Переконайтесь, що у вас є сумісна з Deeplearning4j попередньо навчена модель Word2Vec. Ви можете знайти попередньо навчальні моделі онлайн або навчити власну на відповідному корпусі.
• Підготовка даних: Список ключових слів повинен бути відібраний з вашого набору даних або наукових статей.
• Налаштування параметрів: Налаштуйте кількість кластерів (numClusters) в залежності від вашого набору даних та бажаної точності кластеризації.

Вибір прототипів для навчання на основі багатокласових екземплярів

Вибір прототипів для навчання на основі багатокласових екземплярів

Стаття під назвою “Вибір прототипів для навчання на основі багатокласових екземплярів” була опублікована в журналі Information в жовтні 2023 року та розглядає труднощі застосування алгоритмів навчання на основі екземплярів до задач багатокласової класифікації.

Передумови

У традиційній класифікації з одним міткою, кожен екземпляр асоціюється з однією міткою класу. Однак у багатокласовій класифікації екземпляр може одночасно належати до кількох класів. Алгоритми навчання на основі екземплярів, такі як правило Condensed Nearest Neighbor (CNN) та його варіант одноразового проходу, IB2, ефективні в задачах з одною міткою, але стикаються з труднощами при розширенні до багатокласових даних через складність асоціацій між мітками.

Вибір прототипів

Вибір прототипів передбачає зменшення розміру навчального набору шляхом вибору репрезентативного підмножини екземплярів, відомих як прототипи. Цей процес підвищує ефективність класифікаторів на основі екземплярів, зменшуючи обчислювальні витрати, при цьому зберігаючи або покращуючи точність класифікації.

Вибір прототипів у багатокласовій класифікації

У багатокласовій класифікації вибір прототипів стає складнішим, оскільки обрані прототипи повинні точно відображати кілька комбінацій міток.

Запропоновані варіації

Автори пропонують чотири варіації кожного з алгоритмів CNN та IB2, адаптованих для багатокласових даних. Одна з помітних варіацій представляє нову адаптацію відстані Левенштейна, яка зазвичай використовується для вимірювання схожості рядків, для роботи з багатокласовими екземплярами. Ця адаптація дозволяє більш детально порівнювати екземпляри з кількома мітками, покращуючи вибір репрезентативних прототипів.

Експериментальне дослідження

Експериментальне дослідження було проведено за допомогою дев’яти різних багатокласових наборів даних для оцінки ефективності запропонованих алгоритмів. Результати, підтримані статистичними тестами, показують, що вісім запропонованих підходів досягли значного скорочення розміру навчального набору без втрати точності класифікації. Це збалансоване скорочення даних і точності є важливим для практичного застосування методів навчання на основі екземплярів у багатокласових задачах класифікації.

Наслідки

Результати дослідження показують, що запропоновані алгоритми вибору прототипів можуть ефективно покращити ефективність методів навчання на основі екземплярів у багатокласових задачах класифікації. Скорочуючи розмір навчального набору при збереженні точності, ці алгоритми сприяють застосуванню класифікаторів на основі екземплярів до великих і складних багатокласових наборів даних, розширюючи їх застосовність у різних галузях.

На закінчення, стаття робить внесок у галузь машинного навчання, представляючи інноваційні адаптації алгоритмів вибору прототипів для навчання на основі багатокласових екземплярів, пропонуючи шлях до більш ефективної та точної класифікації в багатокласових контекстах.

Стаття “Вибір прототипів для навчання на основі багатокласових екземплярів” представляє варіації алгоритмів Condensed Nearest Neighbor (CNN) та IB2, адаптованих для багатокласових наборів даних.

Ці алгоритми мають на меті зменшити розмір набору даних, зберігаючи точність класифікації в задачах багатокласового навчання.

Концептуальний огляд:

1. Багатокласові дані: Екземпляри можуть належати до кількох класів одночасно, що потребує спеціалізованого підходу в порівнянні з однотеговими даними.
2. Вибір прототипів: Процес вибору репрезентативного підмножини оригінального набору даних для підвищення обчислювальної ефективності і можливого покращення роботи моделі.
3. Condensed Nearest Neighbor (CNN): Техніка, що ітераційно вибирає прототипи для правильного класифікації навчального набору, зменшуючи розмір набору даних.
4. Алгоритм IB2: Однопрохідна варіація CNN, яка поступово формує набір прототипів під час одного проходу через дані.

Реалізація в Java:

Реалізація цих алгоритмів в Java передбачає кілька кроків.

1. Опис структури даних:

Спочатку необхідно визначити клас для представлення багатокласових екземплярів.

import java.util.Set;  

public class MultilabelInstance {  
 private double[] features;  
 private Set labels;  

 public MultilabelInstance(double[] features, Set labels) {  
 this.features = features;  
 this.labels = labels;  
 }  

 public double[] getFeatures() {  
 return features;  
 }  

 public Set getLabels() {  
 return labels;  
 }  
}

2. Реалізація метрики відстані:

Необхідна функція відстані для вимірювання схожості між екземплярами.

public class DistanceMetrics {  
 public static double euclideanDistance(double[] a, double[] b) {  
 if (a.length != b.length) {  
 throw new IllegalArgumentException("Feature vectors must have the same length.");  
 }  
 double sum = 0.0;  
 for (int i = 0; i < a.length; i++) {  
 sum += Math.pow(a[i] - b[i], 2);  
 }  
 return Math.sqrt(sum);  
 }  
}

3.

Реалізація алгоритму Multilabel CNN:

Ця функція вибирає прототипи з набору даних.

import java.util.ArrayList;  
import java.util.List;  

public class MultilabelCNN {  
 public static List selectPrototypes(List dataset) {  
 List prototypes = new ArrayList<>();  
 for (MultilabelInstance instance : dataset) {  
 if (!correctlyClassifies(instance, prototypes)) {  
 prototypes.add(instance);  
 }  
 }  
 return prototypes;  
 }  

 private static boolean correctlyClassifies(MultilabelInstance instance, List prototypes) {  
 if (prototypes.isEmpty()) {  
 return false;  
 }  
 MultilabelInstance nearest = findNearestNeighbor(instance, prototypes);  
 return nearest.getLabels().equals(instance.getLabels());  
 }  

 private static MultilabelInstance findNearestNeighbor(MultilabelInstance instance, List prototypes) {  
 MultilabelInstance nearest = null;  
 double minDistance = Double.MAX_VALUE;  
 for (MultilabelInstance prototype : prototypes) {  
 double distance = DistanceMetrics.euclideanDistance(instance.getFeatures(), prototype.getFeatures());  
 if (distance < minDistance) {  
 minDistance = distance;  
 nearest = prototype;  
 }  
 }  
 return nearest;  
 }  
}

Реалізація алгоритму Multilabel IB2:

Ця функція поетапно будує набір прототипів за один прохід.

import java.util.ArrayList;  
import java.util.List;  

public class MultilabelIB2 {  
 public static List selectPrototypes(List dataset) {  
 List prototypes = new ArrayList<>();  
 for (MultilabelInstance instance : dataset) {  
 if (prototypes.isEmpty() || !correctlyClassifies(instance, prototypes)) {  
 prototypes.add(instance);  
 }  
 }  
 return prototypes;  
 }  

 private static boolean correctlyClassifies(MultilabelInstance instance, List prototypes) {  
 if (prototypes.isEmpty()) {  
 return false;  
 }  
 MultilabelInstance nearest = findNearestNeighbor(instance, prototypes);  
 return nearest.getLabels().equals(instance.getLabels());  
 }  

 private static MultilabelInstance findNearestNeighbor(MultilabelInstance instance, List prototypes) {  
 MultilabelInstance nearest = null;  
 double minDistance = Double.MAX_VALUE;  
 for (MultilabelInstance prototype : prototypes) {  
 double distance = DistanceMetrics.euclideanDistance(instance.getFeatures(), prototype.getFeatures());  
 if (distance < minDistance) {  
 minDistance = distance;  
 nearest = prototype;  
 }  
 }  
 return nearest;  
 }  
}

Приклад використання:

Ось як ви можете використовувати ці класи:

import java.util.Arrays;  
import java.util.HashSet;  
import java.util.List;  
import java.util.Set;  

public class PrototypeSelectionDemo {  
 public static void main(String[] args) {  
 // Приклад набору даних  
 List dataset = Arrays.asList(  
 new MultilabelInstance(new double[]{1.0, 2.0}, new HashSet<>(Arrays.asList("A", "B"))),  
 new MultilabelInstance(new double[]{1.5, 1.8}, new HashSet<>(Arrays.asList("A"))),  
 new MultilabelInstance(new double[]{5.0, 8.0}, new HashSet<>(Arrays.asList("B", "C"))),  
 new MultilabelInstance(new double[]{6.0, 9.0}, new HashSet<>(Arrays.asList("C")))  
 );  

 // Застосувати Multilabel CNN  
 List cnnPrototypes = MultilabelCNN.selectPrototypes(dataset);  
 System.out.println("CNN вибрані прототипи: " + cnnPrototypes.size());  

 // Застосувати Multilabel IB2  
 List ib2Prototypes = MultilabelIB2.selectPrototypes(dataset);  
 System.out.println("IB2 вибрані прототипи: " + ib2Prototypes.size());  
 }  
}

• Метрика відстані: Тут використовується евклідова відстань, але інші метрики можуть бути більш підходящими в залежності від даних.
• Порівняння міток: Ця реалізація передбачає точне порівняння наборів міток.
  ## Аналіз за допомогою згорткових нейронних мереж виявляє три можливі джерела письмових знаків бронзової доби між Грецією та Індією

Аналіз за допомогою згорткових нейронних мереж виявляє три можливі джерела письмових знаків бронзової доби між Грецією та Індією

Стаття під назвою “Аналіз за допомогою згорткових нейронних мереж виявляє три можливі джерела письмових знаків бронзової доби між Грецією та Індією”, опублікована в журналі Information в квітні 2023 року, представляє нове застосування згорткових нейронних мереж (CNNs) в поєднанні з методами опорних векторів (SVMs) для аналізу взаємозв'язків серед восьми давніх письмових систем з регіонів, що охоплюють Грецію та Індію.

Передісторія

Розуміння походження та взаємозв'язків стародавніх письмових систем є складним завданням, яке традиційно вимагало ручного аналізу з боку епіграфістів та істориків. З'явлення методів машинного навчання відкриває нові можливості для таких аналізів, дозволяючи обробляти великі набори даних та виявляти закономірності, які не завжди помітні через традиційні методи.

Методологія

Дослідники вибрали для аналізу вісім давніх письмових систем: шумерські піктограми, писемність долини Інду, прото-еламітське письмо, кретські ієрогліфи, Лінійне письмо B, фінікійський алфавіт, грецький алфавіт та брахмітське письмо. Для отримання характеристик із зображень знаків цих письмових систем використовували згорткові нейронні мережі (CNN). Далі методи опорних векторів (SVM) застосовувалися для оцінки подібності між парами знаків з різних письмових систем, надаючи числову оцінку, яка кількісно визначає ступінь подібності.

Результати

Аналіз виявив три окремі групи споріднених письмових систем:

1. Група 1: шумерські піктограми, писемність долини Інду та прото-еламітське письмо.
2. Група 2: кретські ієрогліфи та Лінійне письмо B.
3. Група 3: фінікійський, грецький та брахмітський алфавіти.

Ці групи свідчать про можливі історичні зв'язки та шляхи культурної передачі між регіонами, де використовувалися ці письмові системи.

Наслідки

Дослідження демонструє ефективність поєднання CNN та SVM у сфері епіграфії, пропонуючи кількісний підхід для оцінки подібностей між давніми письмовими системами. Ця методологія є доповненням до традиційних якісних аналізів, що дозволяє виявляти зв'язки, які могли бути упущені раніше. Результати сприяють нашому розумінню розвитку та поширення письмових систем у бронзовій добі, підкреслюючи взаємозв'язок ранніх цивілізацій на великій географічній території.

У підсумку, стаття демонструє потенціал методів машинного навчання в історичній лінгвістиці та епіграфії, відкриваючи нові шляхи для досліджень походження та взаємозв'язків давніх письмових систем.

Цей код передбачає використання Deeplearning4j для реалізації нейронної мережі. Модель тренується на попередньо оброблених зображеннях, і визначена проста архітектура CNN, яка тренується.

1.

Завантаження зображень

Ця частина коду відповідає за завантаження та попередню обробку зображень.

import org.datavec.api.io.records.impl.ImageRecordReader;  
import org.datavec.api.io.labels.ParentPathLabelGenerator;  
import org.datavec.api.util.ClassPathResource;  
import org.datavec.api.split.FileSplit;  
import org.nd4j.linalg.api.ndarray.INDArray;  

import java.io.File;  
import java.io.IOException;  
import java.util.List;  

public class ImageLoader {  

 public static List loadImages(String directoryPath) throws IOException {  
 File directory = new ClassPathResource(directoryPath).getFile();  
 ImageRecordReader recordReader = new ImageRecordReader(28, 28, 1, new ParentPathLabelGenerator());  
 recordReader.initialize(new FileSplit(directory));  
 List images = recordReader.next();  
 return images;  
 }  
}

2. Створення моделі CNN

Опис архітектури CNN за допомогою Deeplearning4j.

import org.deeplearning4j.nn.conf.NeuralNetConfiguration;  
import org.deeplearning4j.nn.conf.layers.*;  
import org.deeplearning4j.nn.conf.preprocessor.CnnToFeedForwardPreProcessor;  
import org.deeplearning4j.nn.graph.ComputationGraph;  
import org.deeplearning4j.nn.graph.GraphBuilder;  
import org.nd4j.linalg.activations.Activation;  
import org.nd4j.linalg.lossfunctions.LossFunctions;  
import org.nd4j.linalg.api.memory.MemoryWorkspace;  
import org.nd4j.linalg.api.ndarray.INDArray;  

public class CNNModel {  

 public static ComputationGraph buildModel() {  
 GraphBuilder graphBuilder = new NeuralNetConfiguration.Builder()  
 .graphBuilder()  
 .addInputs("input")  
 .setInputTypes(InputType.convolutionalFlat(28, 28, 1))  
 .addLayer("conv1", new ConvolutionLayer.Builder(5, 5)  
 .nIn(1)  
 .nOut(20)  
 .activation(Activation.RELU)  
 .build(), "input")  
 .addLayer("pool1", new SubsamplingLayer.Builder(SubsamplingLayer.PoolingType.MAX, new int[]{2, 2})  
 .build(), "conv1")  
 .addLayer("conv2", new ConvolutionLayer.Builder(5, 5)  
 .nOut(50)  
 .activation(Activation.RELU)  
 .build(), "pool1")  
 .addLayer("pool2", new SubsamplingLayer.Builder(SubsamplingLayer.PoolingType.MAX, new int[]{2, 2})  
 .build(), "conv2")  
 .addLayer("dense1", new DenseLayer.Builder()  
 .nOut(500)  
 .activation(Activation.RELU)  
 .build(), "pool2")  
 .addLayer("output", new OutputLayer.Builder(LossFunctions.LossFunction.MCXENT)  
 .nOut(8) // Кількість класів (8 письмових систем)  
 .activation(Activation.SOFTMAX)  
 .build(), "dense1")  
 .setOutputs("output");  

 return new ComputationGraph(graphBuilder.build());  
 }  
}

3.

Навчання моделі

Навчіть модель, використовуючи завантажені дані.

import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;  
import org.nd4j.linalg.api.ndarray.INDArray;  
import org.nd4j.linalg.dataset.api.iterator.RecordReaderDataSetIterator;  
import org.deeplearning4j.optimization.listeners.ScoreIterationListener;  
import org.nd4j.linalg.factory.Nd4j;  
import org.nd4j.linalg.dataset.api.iterator.StandardScaler;  

import java.io.IOException;  
import java.util.List;  

public class ModelTrainer {  

 public static void main(String[] args) throws IOException {  
 // Завантаження набору даних  
 List images = ImageLoader.loadImages("path_to_images_directory");  

 // Припустимо, що зображення зберігаються як INDArray, ви можете реалізувати свій спосіб отримання міток  
 // Для простоти використовуємо умовну мітку (вам слід завантажити справжні мітки)  
 INDArray labels = Nd4j.zeros(images.size(), 8); // Припускаємо 8 класів для 8 письмових систем  

 // Створення навчального набору даних  
 INDArray input = Nd4j.vstack(images.toArray(new INDArray[0]));  

 // Створення та навчання моделі  
 ComputationGraph model = CNNModel.buildModel();  

 // Оголошення ітератора даних  
 RecordReaderDataSetIterator iterator = new RecordReaderDataSetIterator(images.size(), 8);  

 // Масштабування вхідних даних  
 StandardScaler scaler = new StandardScaler();  
 scaler.fit(input);  
 scaler.transform(input);  

 // Навчання моделі  
 model.setListeners(new ScoreIterationListener(10)); // Виведення результату навчання кожні 10 ітерацій  
 for (int i = 0; i < 10; i++) {  
 model.fit(input, labels); // Навчання моделі  
 System.out.println("Epoch " + i + " complete");  
 }  
 }  
}

4. Оцінка моделі

Після навчання моделі ви можете оцінити її, використовуючи неперевірені тестові дані.

import org.nd4j.linalg.api.ndarray.INDArray;  

public class ModelEvaluator {  

 public static void evaluateModel(ComputationGraph model, INDArray testData, INDArray testLabels) {  
 INDArray output = model.outputSingle(testData);  

 // Обчислення точності або інших метрик  
 int correct = 0;  
 for (int i = 0; i < testLabels.rows(); i++) {  
 if (output.getInt(i) == testLabels.getInt(i)) {  
 correct++;  
 }  
 }  

 double accuracy = (double) correct / testLabels.rows();  
 System.out.println("Точність: " + accuracy);  
 }  
}

• Попередня обробка зображень: Переконайтеся, що ваші зображення змінені розміром (наприклад, до 28x28 пікселів, як у прикладі). Якщо набір даних не має правильного формату, обробіть його відповідно.
• Завантаження даних: Функція завантаження даних передбачає, що зображення зберігаються в структурі каталогів, де кожен підкаталог є міткою (наприклад, для категорій письмових систем). Ви можете змінити це для вашого набору даних.
• Гіперпараметри моделі: Налаштуйте швидкість навчання, кількість епох і розмір пакету залежно від розміру та складності вашого набору даних.

Археогенетичне видобування даних підтверджує урало-міноянську батьківщину в басейні Дунаю

Археогенетичне видобування даних підтверджує урало-міноянську батьківщину в басейні Дунаю

Стаття під назвою "Археогенетичне видобування даних підтверджує урало-міноянську батьківщину в басейні Дунаю", опублікована в журналі Information у жовтні 2024 року, представляє захоплююче міждисциплінарне дослідження, яке поєднує археогенетичне видобування даних із лінгвістичним аналізом, щоб запропонувати спільне походження урало-міноянських мов і мінойської цивілізації в басейні Дунаю. MDPI

Контекст

Походження мінойської цивілізації, відомої своєю розвинутою культурою на Криті в бронзову добу, давно цікавить науковців. Подібним чином, урало-міноянська мовна родина, до якої належать такі мови, як фінська, угорська та естонська, викликає численні дослідження її прабатьківщини.

Традиційні дослідження в археології та лінгвістиці пропонували різні гіпотези, але нещодавні досягнення в археогенетиці відкривають нові можливості для дослідження цих давніх зв'язків.

Методологія

У дослідженні застосовуються чотири різні типи археогенетичного видобування даних для вивчення можливого спільного походження мінойців та урало-мовних популяцій:

1. Однонуклеотидні поліморфізми (SNP), пов'язані з кольором очей, волосся та шкіри: Аналізуючи специфічні генетичні маркери, пов'язані з пігментацією, дослідники роблять висновки про фенотипічні подібності, що можуть вказувати на спільне походження.
2. Уніпарентальні гаплогрупи: Вивчення мітохондріальної ДНК (мтДНК) та гаплогруп Y-хромосоми дає уявлення про материнські та батьківські лінії, відповідно, висвітлюючи міграції популяцій та генетичну спадкоємність.
3. Зразки стародавньої ДНК (aDNA): Дослідження стародавньої ДНК з археологічних залишків дозволяє простежити генетичні зв'язки між стародавніми популяціями в басейні Дунаю та тими, що проживали в регіонах, пов'язаних з урало-мовними народами та мінойською цивілізацією.
4. Філогенетичний аналіз: Створюючи філогенетичні дерева, дослідники оцінюють генетичні зв'язки та часи дивергенції серед популяцій, що досліджуються.

Результати

Комплексний аналіз виявив значні генетичні схожості між мінойцями та урало-мовними популяціями, що підтверджує гіпотезу про спільну батьківщину в басейні Дунаю. Цей регіон, що охоплює дельту Дунаю, вважається ключовою територією, з якої мінойці могли мігрувати на південь до Егейського моря, а урало-мовні групи, можливо, розселилися на схід та північ вздовж основних річкових систем. MDPI

Наслідки

Цей міждисциплінарний підхід поєднує генетичні дані з лінгвістичними теоріями, припускаючи, що басейн Дунаю був колискою як для мінойської цивілізації, так і для урало-мовної родини. Результати кидають виклик традиційним поглядам, які часто розглядають ці культури ізольовано, замість того, щоб підкреслити потенційну взаємопов'язаність, що може бути обумовлена спільним походженням та міграційними шляхами.

На завершення, стаття демонструє силу поєднання археогенетичного видобування даних з лінгвістичним аналізом для розкриття складних історичних наративів. Пропонуючи спільну батьківщину для мінойців та урало-мовних популяцій в басейні Дунаю, це відкриває нові можливості для досліджень праісторичних рухів і взаємодій, що сформували людську історію.

Ось деякі підходи на основі Java, натхненні методами, описаними в статті:

1. Парсинг та попередня обробка даних

Обробка археогенетичних наборів даних часто передбачає парсинг великих файлів у форматах, таких як CSV або JSON.

Можна використовувати можливості вводу/виводу Java для цього.

import java.io.*;  
import java.util.*;  

public class DataParser {  
 public static List parseCSV(String filePath) throws IOException {  
 List data = new ArrayList<>();  
 try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {  
 String line;  
 while ((line = br.readLine()) != null) {  
 String[] fields = line.split(",");  
 data.add(fields);  
 }  
 }  
 return data;  
 }  
}

## Головний компонентний аналіз (PCA)

PCA — це статистична процедура, яка використовується для підкреслення варіацій і виявлення сильних закономірностей у наборі даних.

У контексті археогенетики PCA може допомогти візуалізувати генетичні подібності та відмінності.

Хоча Java не має вбудованих функцій для PCA, такі бібліотеки, як Apache Commons Math, можуть бути використані.

import org.apache.commons.math3.linear.*;

public class PCAExample {
public static RealMatrix performPCA(RealMatrix data) {
// Припускаємо, що дані відцентровано по середньому значенню
Covariance covariance = new Covariance(data);
RealMatrix covarianceMatrix = covariance.getCovarianceMatrix();
EigenDecomposition ed = new EigenDecomposition(covarianceMatrix);
RealMatrix principalComponents = ed.getV();
return principalComponents;
}
}
```

3. Обчислення генетичної відстані

Обчислення генетичних відстаней між зразками є важливим аспектом археогенетичних досліджень.

Одним з найбільш поширених методів є евклідова відстань.

public class GeneticDistance {  
 public static double euclideanDistance(double[] sample1, double[] sample2) {  
 if (sample1.length != sample2.length) {  
 throw new IllegalArgumentException("Зразки повинні мати однакову довжину");  
 }  
 double sum = 0.0;  
 for (int i = 0; i < sample1.length; i++) {  
 sum += Math.pow(sample1[i] - sample2[i], 2);  
 }  
 return Math.sqrt(sum);  
 }  
}

## Аналіз кластеризації

Алгоритми кластеризації, такі як K-Середніх (K-Means), можуть групувати генетичні дані в кластери, що представляють різні популяції.

Реалізація K-Середніх у Java включає ініціалізацію центроїдів, призначення точок найближчому центроїду та оновлення центроїдів в процесі ітерацій.

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class KMeansClustering {

static class Point {
double[] coordinates;
int cluster;

Point(double[] coordinates) {
this.coordinates = coordinates;
}

double distance(Point other) {
double sum = 0.0;
for (int i = 0; i < this.coordinates.length; i++) {
sum += Math.pow(this.coordinates[i] - other.coordinates[i], 2);
}
return Math.sqrt(sum);
}
}

public static List kMeans(List points, int k, int maxIterations) {
int dimensions = points.get(0).coordinates.length;

// Крок 1: Ініціалізація центроїдів випадковим чином
List centroids = initializeCentroids(points, k);

boolean convergence = false;
int iterations = 0;

while (!convergence && iterations < maxIterations) {
// Крок 2: Призначення точок найближчому центроїду
assignClusters(points, centroids);

// Крок 3: Перерахунок центроїдів
List newCentroids = recalculateCentroids(points, k, dimensions);

// Перевірка на сходження
convergence = centroidsEqual(centroids, newCentroids);
centroids = newCentroids;

iterations++;
}

return centroids;
}

private static List initializeCentroids(List points, int k) {
List centroids = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < k; i++) {
centroids.add(points.get(random.nextInt(points.size())));
}
return centroids;
}

private static void assignClusters(List points, List centroids) {
for (Point point : points) {
double minDistance = Double.MAX_VALUE;
int cluster = -1;
for (int i = 0; i < centroids.size(); i++) {
double distance = point.distance(centroids.get(i));
if (distance < minDistance) {
minDistance = distance;
cluster = i;
}
}
point.cluster = cluster;
}
}

private static List recalculateCentroids(List points, int k, int dimensions) {
List newCentroids = new ArrayList<>();
for (int i = 0; i < k; i++) {
double[] sum = new double[dimensions];
int count = 0;

for (Point point : points) {
if (point.cluster == i) {
for (int j = 0; j < dimensions; j++) {
sum[j] += point.coordinates[j];
}
count++;
}
}

// Уникати ділення на нуль
if (count == 0) {
newCentroids.add(new Point(new double[dimensions]));
} else {
for (int j = 0; j < dimensions; j++) {
sum[j] /= count;
}
newCentroids.add(new Point(sum));
}
}
return newCentroids;
}

private static boolean centroidsEqual(List centroids1, List centroids2) {
for (int i = 0; i < centroids1.size(); i++) {
if (centroids1.get(i).distance(centroids2.get(i)) > 1e-6) {
return false;
}
}
return true;
}

public static void main(String[] args) {
// Приклад: 2D точки
List points = new ArrayList<>();
points.add(new Point(new double[]{1.0, 2.0}));
points.add(new Point(new double[]{1.5, 1.8}));
points.add(new Point(new double[]{5.0, 8.0}));
points.add(new Point(new double[]{8.0, 8.0}));
points.add(new Point(new double[]{1.0, 0.6}));
points.add(new Point(new double[]{9.0, 11.0}));
points.add(new Point(new double[]{8.0, 2.0}));
points.add(new Point(new double[]{10.0, 2.0}));
points.add(new Point(new double[]{9.0, 3.0}));

int k = 3; // Кількість кластерів
int maxIterations = 100;

List centroids = kMeans(points, k, maxIterations);

System.out.println("Центроїди:");
for (Point centroid : centroids) {
for (double coord : centroid.coordinates) {
System.out.print(coord + " ");
}
}
}

System.out.println();
}

System.out.println("\nТочки з кластерами:");
for (Point point : points) {
System.out.print("Точка: ");
for (double coord : point.coordinates) {
System.out.print(coord + " ");
}
System.out.println("Кластер: " + point.cluster);
}
}
}

Візуалізація

Хоча Java зазвичай не використовується для візуалізації даних, інтеграція з бібліотеками, такими як JFreeChart, може допомогти створювати графіки, такі як графіки PCA або дендрограми.

import org.jfree.chart.*;  
import org.jfree.chart.plot.*;  
import org.jfree.data.xy.*;  

public class PCAPlot {  
 public static void plotPCA(double[][] pcaData) {  
 XYSeries series = new XYSeries("PCA Data");  
 for (double[] point : pcaData) {  
 series.add(point[0], point[1]);  
 }  
 XYDataset dataset = new XYSeriesCollection(series);  
 JFreeChart chart = ChartFactory.createScatterPlot(  
 "PCA Plot",  
 "PC1",  
 "PC2",  
 dataset,  
 PlotOrientation.VERTICAL,  
 true,  
 true,  
 false  
 );  
 // Код для відображення графіка буде тут  
 }  
}

Прискорення перевірки відповідності на основі даних через тимчасові алгебри

Прискорення перевірки відповідності на основі даних через тимчасові реляційні знання

Стаття під назвою “Прискорення перевірки відповідності на основі даних через тимчасові реляційні знання,” опублікована в журналі Information у березні 2023 року, пропонує інноваційний підхід до підвищення ефективності перевірки відповідності в тимчасових моделях, використовуючи налаштовану систему реляційних баз даних. MDPI

Передумови

Перевірка відповідності є критично важливим процесом в управлінні бізнес-процесами та інших сферах, таких як кібербезпека, Індустрія 4.0 та електронне здоров'я. Вона полягає у перевірці того, чи послідовності тимчасово впорядкованих і повністю спостережуваних подій відповідають попередньо визначеним моделям або специфікаціям. Ця перевірка є важливою для забезпечення виконання процесів відповідно до плану, виявлення відхилень та сприяння розвитку зрозумілих і надійних систем штучного інтелекту. MDPI

Виклики

Традиційні методи перевірки відповідності часто стикаються з проблемами масштабованості та ефективності, особливо при роботі з великими наборами даних. Збільшення обсягів даних в реальних застосуваннях вимагає більш ефективних алгоритмів і систем, здатних обробляти складні тимчасові запити без втрати продуктивності. MDPI

Запропоноване рішення

Для вирішення цих проблем автори розробили KnoBAB, нову систему управління бізнес-процесами, призначену для ефективних обчислень перевірки відповідності. KnoBAB працює на основі налаштованої реляційної моделі, яка включає тимчасову алгебру для виконання тимчасових запитів, звану xtLTLf. Ця алгебра здатна виражати існуючі тимчасові мови для скінченних та ненульових слідів, такі як Лінійна Тимчасова Логіка для Скінченних Слідів (LTLf). MDPI

Реалізація та паралелізація

Архітектура системи була ретельно реалізована відповідно до кращих практик проектування систем керування реляційними базами даних. Ключовою особливістю KnoBAB є стратегія паралелізації для тимчасових запитів, що перетворює перевірку відповідності на типову задачу для паралельної обробки. Ця паралелізація забезпечує надлінійні прискорення, значно покращуючи продуктивність системи при обробці великих наборів даних. MDPI

Наслідки

Інтегруючи тимчасову логіку з реляційними базами даних і використовуючи техніки паралельної обробки, це дослідження пропонує масштабоване та ефективне рішення для перевірки відповідності в різних сферах. Цей підхід не лише покращує швидкість і масштабованість перевірки відповідності, але й сприяє розвитку зрозумілих і надійних систем штучного інтелекту, дозволяючи негайно оцінювати записані поведінки та пропонувати можливі способи виправлення відхилень.
MDPI

На завершення, стаття представляє значний прорив у галузі перевірки відповідності, пропонуючи систему, що поєднує тимчасову логіку, реляційні бази даних та паралельну обробку для досягнення ефективної та масштабованої перевірки тимчасових моделей. Ця робота має потенціал вплинути на різні сфери, де важливі відповідність процесів і цілісність даних. MDPI

Ось деякі підходи на основі Java, натхненні методологіями статті:

1. Оцінка тимчасової логіки

Оцінка виразів тимчасової логіки над журналами подій є центральним аспектом перевірки відповідності.

Java може бути використана для реалізації таких оцінок.

import java.util.List;  

public class TemporalLogicEvaluator {  
 public static boolean evaluateLTLf(List events, LTLfFormula formula) {  
 // Реалізуйте оцінку формули LTLf над списком подій  
 // Це місце для фактичної реалізації  
 return false;  
 }  
}

2. Паралельна обробка для перевірки відповідності

Стаття наголошує на паралелізації перевірки відповідності для покращення ефективності.

Java має ForkJoinPool, який можна використовувати для паралельної обробки.

import java.util.concurrent.RecursiveTask;  
import java.util.concurrent.ForkJoinPool;  

public class ConformanceChecker extends RecursiveTask {  
 private List events;  
 private LTLfFormula formula;  

 public ConformanceChecker(List events, LTLfFormula formula) {  
 this.events = events;  
 this.formula = formula;  
 }  

 @Override  
 protected Boolean compute() {  
 // Реалізуйте логіку перевірки відповідності тут  
 return TemporalLogicEvaluator.evaluateLTLf(events, formula);  
 }  

 public static boolean parallelConformanceCheck(List events, LTLfFormula formula) {  
 ForkJoinPool pool = new ForkJoinPool();  
 ConformanceChecker task = new ConformanceChecker(events, formula);  
 return pool.invoke(task);  
 }  
}

3. Інтеграція з реляційною базою даних

KnoBAB використовує налаштовану реляційну модель для ефективних обчислень.

Java має JDBC, який можна використовувати для взаємодії з реляційними базами даних.

import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  

public class DatabaseHandler {  
 private Connection connect() throws Exception {  
 // Підключення до бази даних  
 String url = "jdbc:your_database_url";  
 String user = "your_username";  
 String password = "your_password";  
 return DriverManager.getConnection(url, user, password);  
 }  

 public List fetchEvents() throws Exception {  
 String query = "SELECT * FROM events";  
 try (Connection conn = connect();  
 PreparedStatement stmt = conn.prepareStatement(query);  
 ResultSet rs = stmt.executeQuery()) {  
 // Обробіть результат і поверніть список подій  
 }  
 }  
}

## Реалізація тимчасової алгебри запитів

Реалізація тимчасової алгебри запитів, як обговорюється в статті, включає визначення операторів для тимчасової логіки.

Це можна реалізувати в Java, створивши класи для кожного оператора.

public abstract class TemporalOperator {
public abstract boolean evaluate(List events);
}

public class EventuallyOperator extends TemporalOperator {
private TemporalOperator operand;

public EventuallyOperator(TemporalOperator operand) {
this.operand = operand;
}

@Override
public boolean evaluate(List events) {
// Реалізуйте логіку 'eventually' над подіями
return false;
}
}
```

Ці приклади надають основу для реалізації методик перевірки відповідності з урахуванням даних у Java, натхнених методологіями, обговореними в статті.

Для комплексних реалізацій рекомендується використовувати спеціалізовані бібліотеки та фреймворки, призначені для оцінки тимчасової логіки та паралельної обробки.

Спрощення формальної тимчасової перевірки над колонковими базами даних

Спрощення формальної тимчасової перевірки над колонковими базами даних

Стаття під назвою “Streamlining Temporal Formal Verification over Columnar Databases,” опублікована в журналі Information у січні 2024 року, презентує інноваційні алгоритми, розроблені для підвищення ефективності завдань формальної перевірки, зокрема тих, що можуть бути виражені через Лінійну Тимчасову Логіку над кінцевими слідами (LTLf). MDPI

Фон

Формальна перевірка є основою для забезпечення того, щоб системи відповідали заданим тимчасовим обмеженням, відіграючи важливу роль у таких сферах, як управління бізнес-процесами, кібербезпека та охорона здоров'я. Збільшення складності та обсягу даних вимагає більш ефективних методів перевірки. Останні досягнення показали, що технології баз даних можуть значно покращити обчислення для завдань формальної перевірки, виражених у LTLf. MDPI

Виклики

Незважаючи на ці досягнення, інтеграція формальної перевірки з технологіями баз даних все ще знаходиться на ранніх етапах, і існує обмежена кількість оптимізаційних алгоритмів, які можуть управляти величезними обсягами інформації, перевіреної з реальних систем. Це обмеження створює труднощі в ефективній перевірці складних тимчасових обмежень в межах великих наборів даних. MDPI

Пропоноване рішення

Для вирішення цих проблем автор пропонує чотири нові алгоритми, які охоплюють цілу низку виразів LTLf, з метою перевершити попередні найкращі реалізації. Ці алгоритми реалізовані на платформі KnoBAB, системі управління бізнес-процесами, що розроблена для ефективних обчислень перевірки відповідності. KnoBAB працює поверх налаштованої реляційної моделі, включаючи тимчасову алгебру для виконання тимчасових запитів, відому як xtLTLf. Ця алгебра здатна виражати існуючі тимчасові мови для кінцевих і не порожніх слідів, такі як LTLf. MDPI

Реалізація та результати

Реалізація цих алгоритмів у системі KnoBAB демонструє значне покращення продуктивності при обробці великих наборів даних. Завдяки налаштованій тимчасовій алгебрі та реляційній моделі система ефективно спрощує завдання формальної тимчасової перевірки, що робить її цінним інструментом для фахівців, які працюють зі складними тимчасовими даними. MDPI

Наслідки

Це дослідження робить внесок у галузь, надаючи оптимізовані алгоритми, що підвищують ефективність формальної тимчасової перевірки над колонковими базами даних.

Інтеграція цих алгоритмів у системи, такі як KnoBAB, пропонує масштабоване рішення для управління та перевірки великих обсягів тимчасових даних, що є критично важливим для забезпечення відповідності та цілісності в різних сферах. MDPI

У підсумку, стаття представляє значні досягнення в спрощенні процесів формальної тимчасової перевірки, пропонуючи практичні рішення для викликів, що виникають при перевірці тимчасових даних великого масштабу. Запропоновані алгоритми та їх реалізація в системі KnoBAB представляють суттєвий крок вперед в ефективному управлінні та перевірці тимчасових обмежень у складних наборах даних. MDPI

Стаття “Streamlining Temporal Formal Verification over Columnar Databases” обговорює покращення завдань формальної перевірки, зокрема тих, що виражені через Лінійну Тимчасову Логіку над кінцевими слідами (LTLf), за допомогою технологій баз даних. MDPI

Ось деякі підходи на основі Java, натхнені методологіями статті:

1. Оцінка тимчасової логіки

Оцінка виразів тимчасової логіки над журналами подій є ключовою для формальної перевірки.

Java можна використовувати для реалізації таких оцінок.

import java.util.List;  

public class TemporalLogicEvaluator {  
 public static boolean evaluateLTLf(List events, LTLfFormula formula) {  
 // Реалізуйте оцінку формули LTLf над списком подій  
 // Це заповнювач для реальної реалізації  
 return false;  
 }  
}

2. Паралельна обробка для формальної перевірки

Стаття підкреслює важливість паралелізації формальної перевірки для покращення ефективності.

Для паралельної обробки можна використовувати ForkJoinPool у Java.

import java.util.List;  
import java.util.concurrent.RecursiveTask;  
import java.util.concurrent.ForkJoinPool;  

public class FormalVerificationTask extends RecursiveTask {  
 private List events;  
 private LTLfFormula formula;  

 public FormalVerificationTask(List events, LTLfFormula formula) {  
 this.events = events;  
 this.formula = formula;  
 }  

 @Override  
 protected Boolean compute() {  
 // Реалізуйте логіку формальної перевірки тут  
 return TemporalLogicEvaluator.evaluateLTLf(events, formula);  
 }  

 public static boolean parallelFormalVerification(List events, LTLfFormula formula) {  
 ForkJoinPool pool = new ForkJoinPool();  
 FormalVerificationTask task = new FormalVerificationTask(events, formula);  
 return pool.invoke(task);  
 }  
}

3. Інтеграція колонкових баз даних

Стаття обговорює використання колонкових баз даних для ефективних обчислень.

Для взаємодії з такими базами можна використовувати JDBC у Java.

import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.util.ArrayList;  
import java.util.List;  

public class ColumnarDatabaseHandler {  
 private Connection connect() throws Exception {  
 // Підключення до колонкової бази даних  
 String url = "jdbc:your_columnar_database_url";  
 String user = "your_username";  
 String password = "your_password";  
 return DriverManager.getConnection(url, user, password);  
 }  

 public List fetchEvents() throws Exception {  
 String query = "SELECT * FROM events";  
 try (Connection conn = connect();  
 PreparedStatement stmt = conn.prepareStatement(query);  
 ResultSet rs = stmt.executeQuery()) {  
 List events = new ArrayList<>();  
 while (rs.next()) {  
 // Створіть об'єкти Event із результатів запиту та додайте їх до списку  
 }  
 return events;  
 }  
 }  
}

**4.

Реалізація тимчасової алгебри запитів

Реалізація тимчасової алгебри запитів передбачає визначення операторів для тимчасової логіки.

Це можна досягти в Java, створюючи класи для кожного оператора.

import java.util.List;  

public abstract class TemporalOperator {  
 public abstract boolean evaluate(List events);  
}  

public class EventuallyOperator extends TemporalOperator {  
 private TemporalOperator operand;  

 public EventuallyOperator(TemporalOperator operand) {  
 this.operand = operand;  
 }  

 @Override  
 public boolean evaluate(List events) {  
 // Реалізуйте логіку 'eventually' для подій  
 return false;  
 }  
}

Ці приклади надають основу для реалізації технік формальної тимчасової перевірки в Java, натхнених методологіями, обговореними в статті.

Для комплексних реалізацій можна використовувати спеціалізовані бібліотеки та фреймворки, орієнтовані на оцінку тимчасової логіки та паралельну обробку.

Підвищення точності прогнозування затримок рейсів за допомогою мір центральності мережі

Підвищення точності прогнозування затримок рейсів за допомогою мір центральності мережі

Стаття під назвою “Enhancing Flight Delay Predictions Using Network Centrality Measures,” опублікована в журналі Information у вересні 2024 року, представляє інноваційний підхід до покращення точності прогнозування затримок рейсів шляхом інтеграції мір центральності мережі в прогностичні моделі. MDPI

Фон

Точно прогнозувати затримки рейсів є постійним викликом у авіаційній індустрії, що має значні наслідки для авіакомпаній, пасажирів та аеропортових операцій. Традиційні прогностичні моделі часто спираються на такі фактори, як погодні умови, історичні дані про затримки та операційні змінні. Однак ці моделі можуть не повністю відображати складні взаємозалежності, властиві мережі авіатранспортних зв’язків.

Міри центральності мережі

Міри центральності мережі — це метрики, що використовуються в теорії мереж для виявлення найважливіших вершин у графі. В контексті авіаційного транспорту ці міри дозволяють кількісно оцінити важливість аеропортів у мережі на основі їх зв'язності та потоку рейсів. Аналізуючи ці міри центральності, дослідники можуть зрозуміти, як затримки в ключових аеропортах можуть поширюватися через мережу, впливаючи на загальну ефективність системи.

Методологія

У дослідженні використовуються різні міри центральності мережі, зокрема центральність за ступенем, центральність за посередництвом та центральність за близькістю, як предиктори в моделях класифікації затримок рейсів. Ці міри інтегруються в ансамблеві моделі на основі дерев — зокрема, random forest, gradient boosting та CatBoost — які відомі своєю здатністю моделювати складні, нелінійні взаємозв’язки. Моделі тренуються та тестуються на великих обсягах даних про рейси для оцінки їх прогностичної ефективності.

Результати

Інтеграція мір центральності мережі в прогностичні моделі підвищує точність прогнозування затримок рейсів. Ансамблеві моделі на основі дерев, зокрема CatBoost, демонструють найкращі результати у виявленні складних взаємозв'язків між мірою центральності та затримками рейсів. Це покращення свідчить про те, що розуміння структурної важливості аеропортів у мережі надає цінну інформацію для прогнозування затримок.

Імплікації

Результати цього дослідження мають практичне значення для зацікавлених сторін в авіаційній галузі. Авіакомпанії можуть використовувати ці вдосконалені прогностичні моделі для кращого планування розкладу та розподілу ресурсів, що потенційно зменшує вплив затримок. Органи управління аеропортами можуть виявляти критичні вузли в мережі, які потребують більш надійних операційних стратегій для запобігання поширенню затримок.
Додатково, пасажири можуть отримати більш точну інформацію про можливі затримки, що покращить планування подорожей та задоволення від подорожей.

Інтеграція заходів центральності мережі в моделі прогнозування затримок авіарейсів є значним кроком уперед у сфері авіаційної аналітики. Враховуючи складні взаємозалежності в мережі авіаперевезень, цей підхід пропонує більш комплексне розуміння динаміки затримок, відкриваючи шлях до більш ефективних стратегій зменшення затримок та покращення операційної ефективності в авіаційній сфері.

Ось деякі підходи, засновані на Java, натхненні методами, описаними в статті:

1. Попередня обробка даних

Перед створенням прогнозуючих моделей необхідно здійснити попередню обробку даних про авіарейси, зокрема, інтегрувати заходи центральності мережі.

import java.util.List;  

public class DataPreprocessor {  
 public static List preprocess(List rawData) {  
 // Реалізувати очищення даних, витягування ознак і інтеграцію заходів центральності мережі  
 // Це місце для реальної реалізації  
 return processedData;  
 }  
}

2. Реалізація класифікатора Random Forest

Random Forest (Стійкий ліс) є методом ансамблевого навчання, ефективним для задач класифікації.

Хоча Java не має вбудованої реалізації Random Forest, можна скористатися такими бібліотеками, як Weka або Deeplearning4j.

Ось приклад з використанням Weka:

import weka.classifiers.trees.RandomForest;  
import weka.core.Instances;  
import weka.core.converters.ConverterUtils.DataSource;  

public class FlightDelayPredictor {  
 public static void main(String[] args) throws Exception {  
 // Завантаження набору даних  
 DataSource source = new DataSource("flight_data.arff");  
 Instances data = source.getDataSet();  
 data.setClassIndex(data.numAttributes() - 1);  

 // Ініціалізація класифікатора RandomForest  
 RandomForest rf = new RandomForest();  
 rf.setNumTrees(100); // Встановити кількість дерев  

 // Побудова моделі  
 rf.buildClassifier(data);  

 // Оцінка моделі (наприклад, за допомогою крос-валідації)  
 // Це місце для реальної оцінки моделі  
 }  
}

3. Реалізація Gradient Boosting

Gradient Boosting можна реалізувати з використанням таких бібліотек, як XGBoost4J.

Ось приклад:

import ml.dmlc.xgboost4j.java.Booster;  
import ml.dmlc.xgboost4j.java.DMatrix;  
import ml.dmlc.xgboost4j.java.XGBoost;  

public class GradientBoostingPredictor {  
 public static void main(String[] args) throws Exception {  
 // Завантаження даних у DMatrix  
 DMatrix trainData = new DMatrix("train.svm.txt");  
 DMatrix testData = new DMatrix("test.svm.txt");  

 // Встановлення параметрів  
 Map params = new HashMap<>();  
 params.put("eta", 0.1);  
 params.put("max_depth", 6);  
 params.put("objective", "binary:logistic");  

 // Навчання моделі  
 Booster booster = XGBoost.train(trainData, params, 100, null, null);  

 // Прогнозування  
 float[][] predictions = booster.predict(testData);  

 // Оцінка прогнозів  
 // Це місце для реальної оцінки прогнозів  
 }  
}

4. Реалізація CatBoost

CatBoost є бібліотекою для градієнтного бустингу, яка ефективно обробляє категоріальні ознаки.

Хоча CatBoost має нативну підтримку в Python, для його використання в Java потрібно додатково налаштовувати, наприклад, через використання CatBoost Java API або виклик Python скриптів з Java.

5.

Аналіз важливості ознак

Розуміння важливості ознак допомагає інтерпретувати рішення моделі.

Бібліотеки, як-от Weka, надають методи для оцінки важливості ознак.

import weka.attributeSelection.AttributeEvaluator;  
import weka.attributeSelection.InfoGainAttributeEval;  
import weka.core.Instances;  
import weka.core.converters.ConverterUtils.DataSource;  

public class FeatureImportance {  
 public static void main(String[] args) throws Exception {  
 // Завантаження набору даних  
 DataSource source = new DataSource("flight_data.arff");  
 Instances data = source.getDataSet();  
 data.setClassIndex(data.numAttributes() - 1);  

 // Ініціалізація оцінювача  
 AttributeEvaluator evaluator = new InfoGainAttributeEval();  

 // Оцінка ознак  
 for (int i = 0; i < data.numAttributes() - 1; i++) {  
 double score = evaluator.evaluateAttribute(i);  
 System.out.println("Ознака " + data.attribute(i).name() + ": " + score);  
 }  
 }  
}

Коригування визначення порогу виявлення поведінки швидкого вгадування

Коригування визначення порогу виявлення поведінки швидкого вгадування

Стаття під назвою "Коригування визначення порогу виявлення поведінки швидкого вгадування", опублікована в журналі Information в липні 2023 року, розглядає проблему точного виявлення поведінки швидкого вгадування на оцінках шляхом удосконалення методу визначення порогів часу відповіді. MDPI

Передумови

Оцінки є основними інструментами для вимірювання здібностей студентів і їхнього розуміння матеріалу. Однак достовірність результатів оцінок може бути знижена, якщо студенти займаються швидким вгадуванням — відповідають на запитання швидше, ніж зазвичай, не повністю залучаючись до змісту. Така поведінка призводить до ненадійних оцінок, що робить важливим вміння відрізняти справжні відповіді від швидких вгадувань для забезпечення точності оцінювання.

Проблеми визначення порогу

Традиційні методи для виявлення поведінки швидкого вгадування часто використовують фіксовані пороги часу для розрізнення швидких вгадувань і розв'язування задач. Однак ці методи можуть бути надто спрощеними і не враховують таких факторів, як складність завдання, яка може впливати на час відповіді. Як результат, може відбутися неправильне класифікування — або швидке вгадування не буде виявлене, або розумні відповіді будуть помилково ідентифіковані як швидкі вгадування.

Запропоноване рішення

Автори пропонують удосконалений підхід, який враховує складність завдання при визначенні порогів часу відповіді. Оцінюючи складність питання, метод встановлює більш точні пороги, покращуючи виявлення поведінки швидкого вгадування. Крім того, в дослідженні розглядаються різні методи агрегації даних, такі як сума, середнє та максимальний час відповіді, для оцінки їх впливу на точність виявлення швидких вгадувань.

Методологія

Дослідження полягало в проведенні тестів для студентів бакалаврату та магістратури, реєстрації їхніх часів відповіді та відповідей. Аналізуючи ці дані, автори моделювали поведінку швидкого вгадування, коригували пороги на основі складності завдань і оцінювали різні методи агрегації, щоб визначити, який з них найефективніше виявляє швидкі вгадування.

Висновки

Удосконалений метод показав 71% успішності у виявленні поведінки швидкого вгадування, перевершуючи попередні підходи. Це поліпшення підкреслює важливість врахування складності завдання та правильних методів агрегації даних при встановленні порогів часу відповіді, що призводить до більш точного виявлення поведінки швидкого вгадування.

Наслідки

Запровадження цього коригованого методу визначення порогу може підвищити достовірність результатів оцінювання, більш точно відокремлюючи справжні відповіді від швидких вгадувань.
Викладачі та розробники оцінок можуть використовувати ці інсайти для створення більш надійних інструментів оцінювання, що в кінцевому підсумку призведе до більш обґрунтованих рішень щодо навчання та успішності студентів.

Дослідження пропонує значний крок уперед у виявленні поведінки швидкого вгадування шляхом вдосконалення методів визначення порогів для врахування складності завдань та вивчення ефективних технік агрегації даних. Цей підхід сприяє розробці більш точних і надійних оцінок, що забезпечують більш вірне відображення справжніх здібностей та розуміння студентів.

Ось кілька підходів на основі Java, натхнених методами, описаними в статті:

1. Попередня обробка даних

Перед виявленням поведінки швидкого вгадування важливо попередньо обробити дані оцінювання, зокрема, обчислити часи відповіді та інтегрувати рівні складності завдань.

import java.util.ArrayList;  
import java.util.List;  

public class DataPreprocessor {  

 // Функція для обробки відсутніх даних (замінюючи на середнє значення стовпця)  
 public static List preprocess(List rawData) {  
 List processedData = new ArrayList<>();  

 // Обчислення середніх значень для стовпців для заповнення відсутніх значень  
 for (int columnIndex = 0; columnIndex < rawData.get(0).length; columnIndex++) {  
 double sum = 0.0;  
 int count = 0;  

 // Підсумовування всіх ненульових значень для цього стовпця  
 for (Double[] row : rawData) {  
 if (row[columnIndex] != null) {  
 sum += row[columnIndex];  
 count++;  
 }  
 }  

 double mean = (count > 0) ? sum / count : 0.0; // Якщо немає ненульових значень, встановити середнє в 0  

 // Замінити відсутні значення на середнє значення стовпця  
 for (Double[] row : rawData) {  
 if (row[columnIndex] == null) {  
 row[columnIndex] = mean; // Заповнення відсутніх значень середнім  
 }  
 }  
 }  

 return rawData;  
 }  

 // Масштабування числових даних за допомогою Min-Max масштабування  
 public static void scaleData(List data) {  
 int numColumns = data.get(0).length;  

 for (int col = 0; col < numColumns; col++) {  
 double min = Double.MAX_VALUE;  
 double max = -Double.MAX_VALUE;  

 // Пошук мінімальних і максимальних значень для кожного стовпця  
 for (Double[] row : data) {  
 if (row[col] < min) {  
 min = row[col];  
 }  
 if (row[col] > max) {  
 max = row[col];  
 }  
 }  

 // Масштабування даних  
 for (Double[] row : data) {  
 row[col] = (row[col] - min) / (max - min); // Min-Max масштабування  
 }  
 }  
 }  
}

2.

Визначення порогів з урахуванням складності завдань

Визначення порогу часу відповіді з урахуванням складності завдання може покращити виявлення поведінки швидкого вгадування.

public class ThresholdDetermination {  
 public static double calculateThreshold(double itemDifficulty, List responseTimes) {  
 // Реалізуйте логіку для розрахунку порогу на основі складності завдання та часу відповіді  
 // Це місце для фактичної реалізації  
 return threshold;  
 }  
}

2.1 Логістична регресія

Логістична регресія є поширеним алгоритмом для задач двійкової класифікації, таких як передбачення захворювання (наприклад, передбачення, чи має пацієнт певне захворювання на основі вхідних характеристик).

import org.apache.commons.math3.stat.regression.LogisticRegression;  

public class LogisticRegressionModel {  

 private LogisticRegression logisticRegression;  

 public LogisticRegressionModel() {  
 // Ініціалізація моделі логістичної регресії  
 logisticRegression = new LogisticRegression();  
 }  

 // Навчання моделі логістичної регресії  
 public void train(List data, List labels) {  
 // Перетворення даних у формат, який підходить для навчання (наприклад, масиви або матриці)  
 double[][] features = new double[data.size()][data.get(0).length];  
 for (int i = 0; i < data.size(); i++) {  
 features[i] = convertToArray(data.get(i));  
 }  

 double[] target = new double[labels.size()];  
 for (int i = 0; i < labels.size(); i++) {  
 target[i] = labels.get(i);  
 }  

 // Навчання моделі логістичної регресії  
 logisticRegression.fit(features, target);  
 }  

 // Передбачення за допомогою навченої моделі  
 public int predict(Double[] inputData) {  
 double[] inputArray = convertToArray(inputData);  
 return logisticRegression.predict(inputArray);  
 }  

 // Перетворення даних з Double[] в double[]  
 private double[] convertToArray(Double[] data) {  
 double[] result = new double[data.length];  
 for (int i = 0; i < data.length; i++) {  
 result[i] = data[i];  
 }  
 return result;  
 }  
}

2.2 Класифікатор випадкових лісів (Random Forest)

Випадковий ліс (Random Forest) — це ансамблевий метод, що використовується для класифікації та регресії. Тут ми реалізуємо модель випадкового лісу за допомогою відкритої бібліотеки машинного навчання Weka (популярна бібліотека для Java, що містить алгоритми для машинного навчання).

import weka.classifiers.trees.RandomForest;  
import weka.core.Instances;  
import weka.core.converters.ConverterUtils.DataSource;  

public class RandomForestModel {  

 private RandomForest randomForest;  

 public RandomForestModel() {  
 // Ініціалізація моделі RandomForest  
 randomForest = new RandomForest();  
 }  

 // Навчання моделі Random Forest  
 public void train(String filePath) throws Exception {  
 DataSource source = new DataSource(filePath);  
 Instances data = source.getDataSet();  
 // Встановлення індексу класу (припускається, що клас — це останній атрибут)  
 data.setClassIndex(data.numAttributes() - 1);  

 randomForest.buildClassifier(data);  
 }  

 // Передбачення за допомогою моделі Random Forest  
 public double predict(Double[] inputData) throws Exception {  
 Instances dataset = new Instances("PredictionData", inputData);  
 return randomForest.classifyInstance(dataset.instance(0));  
 }  
}

2.3 Нейронна мережа (Глибоке навчання)

Для більш складних задач класифікації можна використовувати Нейронну мережу (Neural Network).

2.4 Нейронна мережа (Глибоке навчання)

Для реалізації цієї моделі ми використаємо бібліотеку DeepLearning4J.

import org.deeplearning4j.nn.api.OptimizationAlgorithm;  
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;  
import org.deeplearning4j.nn.conf.layers.DenseLayer;  
import org.deeplearning4j.nn.conf.layers.OutputLayer;  
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;  
import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;  
import org.nd4j.linalg.api.ndarray.INDArray;  
import org.nd4j.linalg.factory.Nd4j;  

public class NeuralNetworkModel {  

 private MultiLayerNetwork model;  

 public NeuralNetworkModel() {  
 // Налаштування та ініціалізація моделі нейронної мережі  
 MultiLayerConfiguration config = new NeuralNetConfiguration.Builder()  
 .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)  
 .list()  
 .layer(0, new DenseLayer.Builder().nIn(4).nOut(5).build()) // Приклад шарів  
 .layer(1, new OutputLayer.Builder().nIn(5).nOut(2).build()) // Вихідний шар  
 .build();  

 model = new MultiLayerNetwork(config);  
 model.init();  
 }  

 // Навчання моделі  
 public void train(INDArray trainingData, INDArray labels) {  
 model.setListeners(new ScoreIterationListener(100));  
 model.fit(trainingData, labels);  
 }  

 // Передбачення за допомогою навченої моделі  
 public int predict(INDArray input) {  
 INDArray output = model.output(input);  
 return output.getInt(0);  
 }  
}

3. Виявлення поведінки швидкого вгадування

Після визначення порогу наступним кроком є виявлення поведінки швидкого вгадування шляхом порівняння індивідуальних часів відповіді з пороговим значенням.

import java.util.List;  

public class RapidGuessingDetector {  
 public static List detectRapidGuessing(List responseTimes, double threshold) {  
 // Реалізуйте логіку для виявлення поведінки швидкого вгадування  
 // Це місце для фактичної реалізації  
 return rapidGuessingFlags;  
 }  
}

4. Оцінка методів виявлення

Оцінка ефективності методу виявлення є важливою.

5. Оцінка моделі

Це можна зробити, порівнявши виявлені поведінки з міченим датасетом для обчислення таких метрик, як точність (accuracy), точність (precision) і повнота (recall).

public class ModelEvaluator {  

 public static double calculateAccuracy(int[] predicted, int[] actual) {  
 int correct = 0;  
 for (int i = 0; i < predicted.length; i++) {  
 if (predicted[i] == actual[i]) {  
 correct++;  
 }  
 }  
 return (double) correct / predicted.length;  
 }  
}

6. Як все з'єднати

public class Main {  

 public static void main(String[] args) {  
 // Завантажити та попередньо обробити дані  
 List rawData = loadData();  
 DataPreprocessor.scaleData(rawData);  

 // Визначити мітки для класифікації  
 List labels = loadLabels(); // Бінарна класифікація, 1 для позитивних, 0 для негативних  

 // Навчити моделі  
 LogisticRegressionModel logisticRegression = new LogisticRegressionModel();  
 logisticRegression.train(rawData, labels);  

 RandomForestModel randomForest = new RandomForestModel();  
 randomForest.train("path_to_data.arff");  

 NeuralNetworkModel neuralNetwork = new NeuralNetworkModel();  
 INDArray trainingData = Nd4j.create(rawData); // Перетворити на INDArray  
 INDArray trainingLabels = Nd4j.create(labels); // Перетворити мітки на INDArray  
 neuralNetwork.train(trainingData, trainingLabels);  

 // Зробити передбачення  
 int logisticPrediction = logisticRegression.predict(rawData.get(0));  
 double rfPrediction = randomForest.predict(rawData.get(0));  
 int nnPrediction = neuralNetwork.predict(Nd4j.create(rawData.get(0)));  

 // Вивести передбачення та оцінки  
 System.out.println("Logistic Regression Prediction: " + logisticPrediction);  
 System.out.println("Random Forest Prediction: " + rfPrediction);  
 System.out.println("Neural Network Prediction: " + nnPrediction);  
 }  

 private static List loadData() {  
 // Псевдозавантаження даних, замінити на фактичний код завантаження  
 return new ArrayList<>();  
 }  

 private static List loadLabels() {  
 // Псевдозавантаження міток, замінити на фактичний код завантаження міток  
 return new ArrayList<>();  
 }  
}

DEGAIN: Генеративно-суперечливе заповнення відсутніх даних на основі нейронних мереж

Заповнення відсутніх даних на основі Генеративно-Суперечливих Мереж (GAN)

Стаття під назвою “DEGAIN: Генеративно-суперечливе заповнення відсутніх даних”, опублікована в журналі Information у грудні 2022 року, представляє новий підхід до вирішення поширеної проблеми відсутніх даних у наборах даних. Відсутні дані можуть значно погіршити роботу моделей машинного навчання, тому ефективні методи заповнення даних є важливими. Автори пропонують DEGAIN, модель на основі Генеративно-Суперечливих Мереж (GAN), яка призначена для оцінки та заповнення відсутніх значень у наборах даних.

Передумови

Відсутні дані — це поширена проблема в різних сферах, зокрема в охороні здоров'я, фінансах та соціальних науках. Традиційні методи заповнення, такі як заміна середнім значенням або регресійне заповнення, часто не здатні захопити основну розподільність даних, що призводить до упереджених або неточних аналізів. Останні досягнення в галузі машинного навчання розглядають більш складні методи заповнення, і GAN-мережі стають обіцяючим інструментом завдяки своїй здатності моделювати складні розподіли даних.

Модель DEGAIN

DEGAIN ґрунтується на архітектурі GAN, яка складається з двох нейронних мереж — генератора та дискримінатора, які навчаються одночасно через суперечливі процеси. Генератор має на меті створювати правдоподібні дані для заповнення відсутніх значень, тоді як дискримінатор оцінює автентичність згенерованих даних.
Це суперечливе навчання дозволяє DEGAIN вивчати складні патерни в даних, що призводить до більш точного заповнення відсутніх значень.

Оцінка та продуктивність

Автори оцінили ефективність DEGAIN, використовуючи публічно доступні набори даних, зокрема набір даних для розпізнавання літер з 20 000 зразків та 16 вхідними ознаками, а також набір даних SPAM з 4 601 зразками та 57 вхідними ознаками. Результати показали, що DEGAIN перевершує існуючі методи заповнення даних, ефективно захоплюючи розподіл даних і надаючи точні оцінки для відсутніх значень. MDPI

Наслідки

Введення DEGAIN є значним кроком уперед у галузі заповнення відсутніх даних. Використовуючи можливості GAN (Generative Adversarial Networks), DEGAIN пропонує надійний метод для обробки відсутніх даних, що є важливим для підвищення надійності аналізів і продуктивності моделей машинного навчання. Цей підхід має потенціал для застосування в різних сферах, де важлива повнота даних.

Дослідження представляє DEGAIN як ефективну модель на основі GAN для заповнення відсутніх даних, демонструючи перевагу над традиційними методами. Ця робота вносить свій вклад у постійні зусилля з покращення якості та надійності даних у застосуваннях машинного навчання, відкриваючи шлях до більш точних і надійних аналізів у разі відсутності даних.

1. Попередня обробка даних

Першим кроком є попередня обробка даних для виявлення та обробки відсутніх значень, а також нормалізація або масштабування даних за потреби.

import java.util.ArrayList;  
import java.util.List;  

public class DataPreprocessor {  

 public static List preprocess(List rawData) {  
 // Для простоти ми заміняємо відсутні значення (null) на середнє значення стовпця  
 // Це базовий приклад; можуть бути використані більш складні методи (наприклад, k-NN імпутація)  

 List processedData = new ArrayList<>();  

 for (Double[] row : rawData) {  
 Double[] processedRow = new Double[row.length];  
 double sum = 0.0;  
 int count = 0;  

 // Спочатку обчислюємо середнє значення для кожного стовпця, ігноруючи відсутні (null) значення  
 for (int i = 0; i < row.length; i++) {  
 if (row[i] != null) {  
 sum += row[i];  
 count++;  
 }  
 }  

 double mean = sum / count;  

 // Замінюємо відсутні значення на обчислене середнє  
 for (int i = 0; i < row.length; i++) {  
 if (row[i] == null) {  
 processedRow[i] = mean;  
 } else {  
 processedRow[i] = row[i];  
 }  
 }  

 processedData.add(processedRow);  
 }  

 return processedData;  
 }  
}

2. Реалізація моделі GAN

Ми використаємо DJL (Deep Java Library) для налаштування простої моделі GAN. DJL — це бібліотека для глибокого навчання на Java, яка підтримує тренування та інференцію нейронних мереж. Ми створимо просту модель генератора та дискримінатора, які є основними компонентами GAN.

import ai.djl.Application;  
import ai.djl.ModelException;  
import ai.djl.ModelException;  
import ai.djl.ndarray.NDArray;  
import ai.djl.ndarray.NDManager;  
import ai.djl.training.Trainer;  
import ai.djl.training.dataset.Dataset;  
import ai.djl.translate.TranslateException;  

public class GANModel {  

 private Trainer trainer;  

 // Ініціалізація GAN (моделі генератора та дискримінатора)  
 public GANModel() {  
 // Завантажте або визначте свої моделі GAN (Генератор, Дискримінатор) тут.  
 // Приклад з DJL, ви можете завантажити попередньо навчені моделі або визначити свої власні  
 }  

 // Навчання моделі GAN  
 public void train(List trainingData) {  
 // Реалізуйте логіку тренування для GAN, передаючи навчальні дані  
 // Цей крок передбачає налаштування набору даних, визначення функцій втрат і оптимізацію моделі.  
 for (int epoch = 0; epoch < 1000; epoch++) {  
 // Ваш код для тренування  
 // Тут відбуватиметься суперечливе навчання між генератором та дискримінатором  
 }  
 }  
}

3.

Імпутація даних

Модель GAN буде навчена на доступних даних (де відсутні значення замінено). Після навчання модель генератора можна використовувати для прогнозування (імпутації) відсутніх даних.

public class DataImputer {  

 // Цей метод використовує модель генератора GAN для імпутації відсутніх значень  
 public static Double[] impute(GANModel ganModel, Double[] dataWithMissingValues) {  
 // Генеруємо імпутовані значення, використовуючи навчену модель GAN  
 NDArray inputData = convertToNDArray(dataWithMissingValues);  
 NDArray imputedData = ganModel.generate(inputData);  

 // Перетворюємо знову імпутовані дані з формату NDArray в Double[] або інший підходящий формат  
 return convertToDoubleArray(imputedData);  
 }  

 private static NDArray convertToNDArray(Double[] data) {  
 // Перетворюємо ваші дані в формат NDArray  
 // DJL використовує NDArray для представлення багатовимірних масивів/тензорів  
 NDManager manager = NDManager.newBaseManager();  
 return manager.create(data);  
 }  

 private static Double[] convertToDoubleArray(NDArray array) {  
 // Перетворюємо NDArray назад у бажаний формат, наприклад, масив Double[]  
 long[] shape = array.getShape().getShape();  
 Double[] result = new Double[(int) shape[0]];  
 for (int i = 0; i < result.length; i++) {  
 result[i] = array.getFloat(i);  
 }  
 return result;  
 }  
}

4. Оцінка ефективності імпутації

Після імпутації відсутніх значень потрібно оцінити якість імпутації. Найпоширеніший спосіб оцінити ефективність — це обчислення середньоквадратичної помилки (MSE) між імпутованими даними та реальними даними.

public class EvaluationMetrics {  

 public static double calculateMSE(Double[] imputedData, Double[] actualData) {  
 double sum = 0.0;  
 int n = imputedData.length;  

 for (int i = 0; i < n; i++) {  
 double diff = imputedData[i] - actualData[i];  
 sum += diff * diff;  
 }  

 return sum / n;  
 }  
}

5. Збірка всього разом

Загальний процес включає попередню обробку даних, навчання GAN, імпутацію відсутніх значень та оцінку ефективності імпутації.

import java.util.ArrayList;  
import java.util.List;  

public class Main {  
 public static void main(String[] args) {  
 // 1. Завантажуємо набір даних (це макет завантаження даних)  
 List rawData = loadData();  

 // 2. Попередньо обробляємо дані (обробляємо відсутні значення)  
 List processedData = DataPreprocessor.preprocess(rawData);  

 // 3. Ініціалізуємо та тренуємо модель GAN  
 GANModel ganModel = new GANModel();  
 ganModel.train(processedData);  

 // 4. Імпутуємо відсутні дані (імітуємо з даними з відсутніми значеннями)  
 Double[] dataWithMissingValues = rawData.get(0); // Приклад: беремо перший рядок  
 Double[] imputedData = DataImputer.impute(ganModel, dataWithMissingValues);  

 // 5. Оцінюємо ефективність імпутації  
 double mse = EvaluationMetrics.calculateMSE(imputedData, rawData.get(0));  
 System.out.println("Середньоквадратична помилка: " + mse);  
 }  

 private static List loadData() {  
 // Цей метод має завантажити ваш набір даних  
 // Повертаємо макетні дані для ілюстрації  
 List data = new ArrayList<>();  
 data.add(new Double[]{1.0, 2.0, null, 4.0, 5.0}); // Приклад рядка з відсутнім значенням  
 return data;  
 }  
}




Перекладено з: [Best IDEAS (International Database Engineered Applications Symposium) Dec `24 using Java](https://medium.com/@yugalnandurkar5/best-ideas-international-database-engineered-applications-symposium-dec-24-using-java-526ccd1c57ac)