Основы методов искусственного интеллекта. Учебно-методическое пособие

#Запуск правил engine.activate(“family”)

#Запросы к базе знаний

for x, z in engine.prove _ 1 _ goal(“grandparent(‘Alice’, $z)”): print(z)

Пример кода на Python для онтологий с помощью библиотеки rdflib:

from rdflib import Graph, Literal, RDF, RDFS, Namespace

onto = Graph()

#Создаем пространство имен для онтологии ont = Namespace(“http://example.org/onto/”)

#Добавляем классы

onto.add((ont.Person, RDF.type, RDFS.Class)) onto.add((ont.Animal, RDF.type, RDFS.Class))

# Добавляем свойства

onto.add((ont.hasName, RDF.type, RDF.Property)) onto.add((ont.hasName, RDFS.domain, ont.Person)) onto.add((ont.hasName, RDFS.domain, ont.Animal)) onto.add((ont.hasName, RDFS.range, RDFS.Literal))

# Сохраняем онтологию в файл onto.serialize(“my _ ontology.rdf”, format=“xml”)

Пример SPARQL-запроса к онтологии, созданной с помощью библиотеки owlready2:

from rdflib import Graph, Literal, URIRef from rdflib.namespace import RDF, RDFS

#Создаем граф RDFLib и загружаем в него онтологию g = Graph()

g.load(“my _ ontology.owl”)

#SPARQL-запрос для поиска всех экземпляров класса Person и вывода их имен

qres = g.query(

21

“““SELECT ?person _ name WHERE {

?person rdf:type my _ ontology:Person . ?person my _ ontology:hasName ?person _ name .

}”””)

# Выводим результаты запроса for row in qres:

print(row)

3. Рассуждение.

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

Дедуктивное рассуждение — это метод логического вывода, при котором из общего утверждения делаются выводы о конкретных случаях.

Например, если утверждается, что все люди смертны, а Александр является человеком, то можно сделать вывод, что Александр смертен. В дедуктивном рассуждении заключения следуют из предпосылок.

Пример дедуктивного рассуждения на Python:

#Предположим, что у нас есть набор предпосылок: a = True

b = False

#Используя эти предпосылки, мы можем сделать логический вывод: if a and not b:

print(“Предпосылки верны, следовательно вывод верен.”) else:

print(“Предпосылки неверны, следовательно вывод неверен.”)

Индуктивное рассуждение — это метод логического вывода, при котором из конкретных случаев делаются выводы о более общих закономерностях. Например, если каждый раз, когда я видела кошку, она была черного цвета, то я могу сделать вывод, что все кошки черные. В индуктивном рассуждении заключения не являются строго логическими, но они могут быть вероятными или подтвержденными опытом.

Пример индуктивного рассуждения на Python:

#Предположим, у нас есть список чисел: numbers = [1, 2, 3, 4, 5]

#Мы можем сделать индуктивный вывод о том, что все числа в списке больше 0:

for num in numbers:

22

if num <= 0:

неверен.”) print(“Не все числа в списке больше 0, следовательно вывод break

else:

print(“Все числа в списке больше 0, следовательно,вывод верен.”)

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

Например, если я знаю, что в прошлом 80 % людей, посетивших определенный ресторан, были довольны едой, то я могу использовать байесовский подход, чтобы определить вероятность того, что следующий человек, посетивший ресторан, будет доволен едой.

Пример байесовского рассуждения на Python:

# Предположим, у нас есть данные о том, сколько различных видов фруктов было продано в магазине:

apples _ sold = 100 oranges _ sold = 50 total _ sales = 500

# Мы можем использовать байесовский подход для оценки вероятности того, что следующий проданный фрукт будет яблоком:

apple _ probability = apples _ sold / total _ sales

print(f“Вероятность продажи яблок следующей покупкой: {apple _ probability}”

4. Обучение.

Эта группа методов предполагает использование данных для изучения закономерностей и взаимосвязей, чтобы делать прогнозы или решать проблемы.

Примеры методов обучения включают контролируемое обучение, неконтролируемое обучение и обучение с подкреплением.

Контролируемоеобучение — это метод обучения, при котором модель обучается на основе предоставленныхданных,содержащихправильныеответы.Основнаяидеязаключаетсявтом, что модель строит функцию отображения, которая связывает входные данные с правильными ответами. Затем модель может использоваться для предсказания правильного ответа для новых входных данных.

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

import pandas as pd

from sklearn.linear _ model import LinearRegression

23

# Загрузка данных

data = pd.read _ csv(‘houses.csv’)

#Разделение данных на входные и выходные переменные

X = data.iloc[:, :-1].values y = data.iloc[:, 1].values

#Разделение данных на обучающую и тестовую выборки

from sklearn.model _ selection import train _ test _ split

X _ train, X _ test, y _ train, y _ test = train _ test _ split(X, y, test _ size=0.2, random _ state=0)

# Обучение модели

regressor = LinearRegression() regressor.fit(X _ train, y _ train)

# Прогнозирование результатов на тестовых данных y _ pred = regressor.predict(X _ test)

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

Примеры алгоритмов неконтролируемого обучения:

–метод главных компонент (PCA);

–кластеризация K-средних;

–t-SNE.

Пример неконтролируемого обучения — метод главных компонент:

from sklearn.decomposition import PCA from sklearn.datasets import load _ iris

iris = load _ iris()

X = iris.data

pca = PCA(n _ components=2)

X _ reduced = pca.fit _ transform(X)

Кластеризация K-средних — это один из наиболее популярных алгоритмов неконтролируемого обучения, который используется для разбиения набора данных на k кластеров.

Алгоритм K-средних основан на минимизации суммы квадратов расстояний между точками и центрами кластеров.

Алгоритм K-средних работает следующим образом:

a)инициализируем k центры кластеров случайным образом;

b)для каждой точки данных находим ближайший центр кластера и присваиваем ей соответствующий кластер;

c)пересчитываем центры кластеров, используя среднее значение всех точек данных, принадлежащих к этому кластеру.

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

Пример кода для кластеризации K-средних на датасете iris:

24

import numpy as np

import matplotlib.pyplot as plt from sklearn.cluster import KMeans

from sklearn.datasets import load _ iris

iris = load _ iris()

X = iris.data[:, :2] y = iris.target

kmeans = KMeans(n _ clusters=3, random _ state=0) kmeans.fit(X)

plt.scatter(X[:,0], X[:,1], c=kmeans.labels _ )

plt.scatter(kmeans.cluster _ centers _[:,0], kmeans.cluster _ centers _[:,1], marker=‘x’, s=100, linewidths=3, color=‘r’)

plt.show()

Вэтом примере загружается датасет iris, который содержит информацию о длине

иширинелепестковичашелистиковцветовирисов.Используютсятолькопервыедвефункции для удобства визуализации.

Затем создается объект KMeans, которому передается параметр n _ clusters=3, что означает, что мы хотим разбить наш набор данных на три кластера.

После обучения KMeans визуализируем результаты с помощью scatter plot, где каждая точка находится на плоскости, соответствующей значениям первых двух функций,

а цвет точки указывает на ее принадлежность к одному из кластеров (рис. 6). Красным крестом на графике будут обозначены центры кластеров, найденные алгоритмом KMeans1.

Рис. 6. Визуализация кластеризации данных с использованием библиотек Python

t-SNE (t-distributed stochastic neighbor embedding) — это алгоритм многомерного шкалиро-

вания, который используется для визуализации высокоразмерных данных вдвух или трех измерениях. Он основан на вероятностной модели, которая стремится сохранить близость то-

1 Датасет для работы взят с сайта https://www.kaggle.com/datasets/uciml/iris.

25

чек в исходном пространстве в новом пространстве, используя многомерное распределение t-Student. Основным преимуществом t-SNE является способность сохранять сложные структуры и отношения между точками данных.

Алгоритм t-SNE работает следующим образом:

a)определяется мера расстояния между парами точек данных в исходном пространстве;

b)вычисляются вероятности того, что пара точек должна быть выбрана в качестве соседей на основе меры расстояния;

c)строится вероятностное распределение t-Student на основе этих вероятностей;

d)определяется мера расстояния между парами точек данных в новом пространстве;

e)оптимизируется мера расстояния вновом пространстве так, чтобы минимизировать расхождение между двумя распределениями вероятности.

Пример кода на Python для визуализации датасета MNIST с помощью t-SNE:

import numpy as np

import matplotlib.pyplot as plt from sklearn.manifold import TSNE

from sklearn.datasets import load _ digits

digits = load _ digits()

X = digits.data y = digits.target

tsne = TSNE(n _ components=2, random _ state=0)

X _ tsne = tsne.fit _ transform(X)

plt.scatter(X _ tsne[:,0], X _ tsne[:,1], c=y) plt.show()

В этом примере загружается датасет MNIST2, который содержит изображения рукописных цифр. Мы используем объектTSNE, чтобы преобразовать наши данные в двумерное пространство. Затем создаем scatter plot, где каждая точка соответствует одному изображению, а ее координаты в двумерном пространстве определяются t-SNE. Цвет точки указывает на соответствующую цифру. На графике можно увидеть, что точки, соответствующие различным цифрам, имеют разные цвета и находятся в разных областях пространства (рис. 7).

2 Датасет для работы взят с сайта https://www.tensorflow.org/datasets/catalog/mnist?hl=ru.

26

Рис. 7. Визуализация представления данных

Мы можем использовать эту визуализацию, чтобы получить представление о том, как различные цифры связаны между собой в пространстве высокой размерности.

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

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

Примеры алгоритмов обучения с подкреплением: Q-обучение, SARSA, Actor-Critic. Пример обучения с подкреплением — Q-обучение:

import gym

import numpy as np

env = gym.make(“FrozenLake-v0”)

Q = np.zeros([env.observation _ space.n, env.action _ space.n])

alpha = 0.8 gamma = 0.95

num _ episodes = 2000

for i in range(num _ episodes): state = env.reset()

done = False while not done:

action = np.argmax(Q[state,:] + np.random.randn(1,env.action _ space.n)*(1./(i+1)))

new _ state, reward, done, _ = env.step(action)

Q[state,action] = Q[state,action] + alpha*(reward + gamma*np. max(Q[new _ state,:]) - Q[state,action])

state = new _ state

27

Этот код обучает Q-обучение на окружении FrozenLake-v0 из библиотеки OpenAI Gym. Мы инициализируем матрицу Q нулями, а затем обновляем ее с помощью цикла обучения. В каждом эпизоде мы сбрасываем состояние окружения, получаем действие с помощью стратегии выбора действия (в данном случае — $\epsilon$-жадной стратегии), выполняем действие, получаем новое состояние и награду и обновляем матрицу Q с помощью обновления

Q-функции Q-learning.

SARSA(State-Action-Reward-State-Action)— это алгоритм обучения сподкреплением, кото-

рый используется для обучения агента в задачах управления на основе обратной связи среды. Он является одним из методов обучения с подкреплением на основе Q-обучения. Алгоритм SARSA работает следующим образом:

a)наблюдается текущее состояние среды;

b)выбирается действие на основе текущего состояния и стратегии выбора действий (на-

пример, epsilon-greedy);

c)выполняется выбранное действие и получается награда и новое состояние;

d)выбирается следующее действие на основе нового состояния и текущей стратегии выбора действий;

e)обновляется оценка Q-функции на основе полученной награды и следующего состоя-

ния.

Повторяем шаги a–e до тех пор, пока не достигнем конечного состояния.

Пример кода на Python для обучения агента методом SARSA в простой среде Gridworld:

import numpy as np

#Определяем среду Gridworld gridworld = np.array([

[0, 0, 0, 1], [0, 0, 0, -1], [0, 0, 0, 0], [0, 0, 0, 0]

])

#Определяем начальное состояние и другие параметры state = (0, 0)

alpha = 0.1 # скорость обучения

gamma = 0.9 # коэффициент дисконтирования epsilon = 0.1 # вероятность случайного действия

#Определяем начальные значения Q-функции для каждой пары состоя- ние-действие

q = np.zeros((4, 4, 4))

# Определяем возможные действия

actions = [(0, 1), (0, -1), (1, 0), (-1, 0)]

# Обучаем агента в среде Gridworld с помощью SARSA for episode in range(100):

28

# Выбираем действие на основе текущего состояния и стратегии выбора действий

if np.random.rand() < epsilon: action = np.random.randint(4)

else:

action = np.argmax(q[state[0], state[1]])

# Выполняем выбранное действие и получаем награду и новое состояние

[1]) new _ state = (state[0] + actions[action][0], state[1] + actions[action] reward = gridworld[new _ state[0], new _ state[1]]

# Выбираем следующее действие на основе нового состояния и текущей стратегии

if np.random.rand() < epsilon:

new _ action = np.random.randint(4) else:

new _ action = np.argmax(q[new _ state[0], new _ state[1]])

# Обновляем оценку Q-функции на основе полученной награды и следующего состояния

q[state[0], state[1], action] += alpha * (

reward + gamma * q[new _ state[0], new _ state[1], new _ action] - q[state[0], state[1], action])

#Переходим в новое состояние state = new _ state

#Используем обученную Q-функцию для выбора действий в среде

Gridworld

state = (0, 0) import numpy as np

while True:

if new _ state[0] < 0 or new _ state[0] >= gridworld.shape[0] or new _ state[1] < 0 or new _ state[1] >= gridworld.shape[1]:

print(“Out of bounds”) break

if gridworld[new _ state[0], new _ state[1]] == -1:

29

print(“Game over”) break

state = new _ state

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

иконечным состоянием в правом нижнем углу:

Current state: (0,0), action: (0,1)

Current state: (0,1), action: (0,1)

Current state: (0,2), action: (0,1)

Current state: (0,3), action: (0,1)

Out of bounds

Используется алгоритм SARSA для обучения агента выбору действия в зависимости от текущего состояния среды. Мы обновляем Q-функцию на каждом шаге ииспользуем ее для выбора действий.

После обучения мы проверяем, как агент выбирает действия в среде Gridworld, используя обученную Q-функцию.

Actor-Critic (Агент-Критик) — это алгоритм обучения с подкреплением, который комбинирует преимущества двух подходов: Policy Gradient и Value-based методов.

Воснове этого метода лежит разделение обучаемой модели на две части: Агент (Actor)

иКритик (Critic). Агент отвечает за выбор оптимальных действий в данном состоянии, а Критик — за оценку ценности состояний и действий. Оба компонента обучаются параллельно, их веса корректируются на каждом шаге обучения.

Пример реализации Actor-Critic на Python с использованием библиотеки PyTorch:

import torch

import torch.nn as nn import torch.optim as optim import gym

# Определяем архитектуру сетей Агента и Критика class ActorCritic(nn.Module):

def _ _ init _ _ (self, input _ size, output _ size, hidden _ size): super(ActorCritic, self). _ _ init _ _ ()

self.actor = nn.Sequential( nn.Linear(input _ size, hidden _ size), nn.ReLU(),

nn.Linear(hidden _ size, output _ size), nn.Softmax(dim=-1)

)

self.critic = nn.Sequential( nn.Linear(input _ size, hidden _ size), nn.ReLU(),

30