text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Проектируем мульти-парадигменный язык программирования. Часть 4 — Основные конструкции языка моделирования
Продолжаем рассказ о создании мульти-парадигменного языка программирования, сочетающего декларативный стиль с объектно-ориентированным и функциональным, который был бы удобен при работе со слабоструктурированными данными и интеграции данных из разрозненных источников. Наконец-то после [введения](https://habr.com/ru/post/521158/) и обзоров [существующих мульти-парадигменных технологий](https://habr.com/ru/post/522530/) и [языков представления знаний](https://habr.com/ru/post/526410/) мы добрались до описания той части гибридного языка, которая ответственна за описание модели предметной области. Я назвал ее **компонентой моделирования**.
Компонента моделирования предназначена для декларативного описания модели предметной области в форме онтологии — сети из экземпляров данных (фактов) и абстрактных понятий, связанных между собой с помощью отношений. В ее основе лежит фреймовая логика — гибрид объектно-ориентированного подхода к представлению знаний и логики первого порядка. Ее основной элемент — понятие, описывающее моделируемый объект с помощью набора атрибутов. Понятие строится на основе других понятий или фактов, исходные понятия назовем **родительскими**, производное — **дочерним**. Отношения связывают значения атрибутов дочернего и родительских понятий или ограничивают их возможные значения. Я решил включить отношения в состав определения понятия, чтобы вся информация о нем находилась по возможности в одном месте. Стиль синтаксиса для определений понятий будет похож на SQL — атрибуты, родительские понятия и отношения между ними должны быть разнесены по разным секциям.
В этой публикации я хочу представить основные способы определения понятий.
Во-первых, понятие, которое строится путем **трансформации родительских понятий**.
Во-вторых, объектно-ориентированный стиль подразумевает **наследование** — значит понадобится механизм, позволяющий создавать понятие путем наследования атрибутов и отношений родительских понятий, расширяя или сужая их.
В-третьих, я считаю, что будет полезным механизм, позволяющий задать **отношения** между равноправными понятиями — без разделения на дочернее и родительские понятия.
А теперь приступим к подробному рассмотрению основных типов понятий компоненты моделирования.
#### Начнем с фактов
Факты представляют собой описание конкретных знаний о предметной области в виде именованного набора пар «ключ-значение»:
```
fact <имя факта> {
<имя атрибута> : <значение атрибута>
...
}
```
Например:
```
fact product {
name: “Cabernet Sauvignon”,
type: “red wine”,
country: “Chile”
}
```
Имя факта может быть не уникальным, например, может быть множество продуктов с разным названием, типом и страной происхождения. Будем считать факты идентичными, если совпадают их имена, а также имена и значения их атрибутов.
Можно провести аналогию между фактами компоненты моделирования и фактами языка Prolog. Их отличие заключается только в синтаксисе. В Prolog аргументы фактов идентифицируются по их позиции, а атрибуты фактов компоненты моделирования — по имени.
#### Понятия
Понятие представляет собой структуру, описывающую абстрактную сущность и основанную на других понятиях и фактах. Определение понятия включает в себя имя, списки атрибутов и дочерних понятий. А также логическое выражение, описывающее зависимости между его (дочернего понятия) атрибутами и атрибутами родительских понятий, позволяющие вывести значение атрибутов дочернего понятия:
```
concept <имя понятия> <псевдоним понятия> (
<имя атрибута> = <выражение>,
...
)
from
<имя родительского понятия> <псевдоним родительского понятия> (
<имя атрибута> = <выражение>
...
),
…
where <выражение отношений>
```
Пример определения понятия *profit* на основе понятий *revenue* и *cost*:
```
concept profit p (
value = r.value – c.value,
date
) from revenue r, cost c
where p.date = r.date = c.date
```
Определение понятия похоже по форме на SQL запрос, но вместо имени таблиц нужно указывать имена родительских понятий, а вместо возвращаемых столбцов — атрибуты дочернего понятия. Кроме того, понятие имеет имя, по которому к нему можно обращаться в определениях других понятий или в запросах к модели. Родительским понятием может быть как непосредственно понятие, так и факты. Выражение отношений в секции *where* – это булево выражение, которое может включать логические операторы, условия равенства, арифметические операторы, вызовы функций и др. Их аргументами могут быть переменные, константы и ссылки на атрибуты как родительских так и дочернего понятий. Ссылки на атрибуты имеют следующий формат:
```
<псевдоним понятия>.<имя атрибута>
```
По сравнению с фреймовой логикой в определении понятия его структура (атрибуты) объединена с отношениями с другими понятиями (родительские понятия и выражение отношений). С моей точки зрения это позволяет сделать код более понятным, так как вся информация о понятии собрана в одном месте. А также соответствует принципу инкапсуляции в том смысле, что детали реализации понятия скрыты внутри его определения. Для сравнения небольшой пример на языке фреймовой логики можно найти в прошлой [публикации](https://habr.com/ru/post/526410/).
Выражение отношений имеет конъюнктивную форму (состоит из выражений, соединенных логическими операциями «AND») и должно включать условия равенства для всех атрибутов дочернего понятия, достаточные для определения их значений. Кроме того, в него могут входить условия, ограничивающие значения родительских понятий или связывающие их между собой. Если в секции *where* будут связаны между собой не все родительские понятия, то механизм логического вывода вернет все возможные комбинации их значений в качестве результата (аналогично операции *FULL JOIN* языка SQL).
Для удобства часть условий равенства атрибутов может быть вынесена в секции атрибутов дочернего и родительских понятий. Например, в определении понятия *profit* условие для атрибута *value* вынесено в секцию атрибутов, а для атрибута *date* – оставлено в секции *where*. Также можно перенести их и в секцию *from*:
```
concept profit p (
value = r.value – c.value,
date = r.date
) from revenue r, cost c (date = r.date)
```
Такой синтаксический сахар позволяет сделать зависимости между атрибутами более явными и выделить их из остальных условий.
Понятия соответствуют правилам в Prolog но имеют немного другую семантику. Prolog делает акцент на построении логически связанных высказываний и вопросам к ним. Понятия же в первую очередь предназначены для структурирования входных данных и извлечения информации из них. Атрибуты понятий соответствуют аргументам термов Prolog. Но если в Prolog аргументы термов связываются с помощью переменных, то в нашем случае к атрибутам можно непосредственно обращаться по их именам.
Поскольку список родительских понятий и условия отношений разнесены по отдельным секциям, логический вывод будет немного отличаться от такового в Prolog. Опишу в общем виде его алгоритм. Вывод родительских понятий будет выполнен в том порядке, в котором они указаны в секции *from*. Поиск решения для следующего понятия выполняется для каждого частичного решения предыдущих понятий так же, как и в SLD резолюции. Но для каждого частичного решения выполняется проверка истинности выражения отношений из секции *where*. Поскольку это выражение имеет форму конъюнкции, то каждое подвыражение проверяется отдельно. Ели подвыражение ложно, то данное частичное решение отвергается и поиск переходит к следующему. Если часть аргументов подвыражения еще не определена (не связана со значениями), то его проверка откладывается. Если подвыражением является оператор равенства и определен только один из его аргументов, то система логического вывода найдет его значение и попытается связать его с оставшимся аргументом. Это возможно, если свободным аргументом является атрибут или переменная.
Например, при выводе сущностей понятия *profit* сначала будут найдены сущности понятия *revenue*, и, соответственно, значения его атрибутов. После чего равенство *p.date = r.date = c.date* в секции *where* даст возможность связать со значениями атрибуты *date* и других понятий. Когда логический поиск доберется до понятия *cost*, значение его атрибута *date* будет уже известно и будет является входным аргументом для этой ветви дерева поиска. Подробно рассказать об алгоритмах логического вывода я планирую в одной из следующих публикаций.
Отличие от Prolog заключается в том, что в правилах Prolog все является предикатами — и обращения к другим правилам и встроенные предикаты равенства, сравнения и др. И порядок их проверки нужно указывать явным образом, например, сначала должны идти два правила а затем равенство переменных:
```
profit(value,date) :- revenue(rValue, date), cost(cValue, date), value = rValue – cValue
```
В таком порядке они и будут выполнены. В компоненте моделирования же предполагается, что все вычисления условий в секции *where* являются детерминированными, то есть не требуют рекурсивного погружения в следующую ветвь поиска. Поскольку их вычисление зависит только от их аргументов, они могут быть вычислены в произвольном порядке по мере связывания аргументов со значениями.
В результате логического вывода все атрибуты дочернего понятия должны быть связаны со значениями. А также выражение отношений должно быть истинно и не содержать неопределенных подвыражений. Стоит заметить, что вывод родительских понятий не обязательно должен быть успешным. Допустимы случаи, когда требуется проверить неудачу выведения родительского понятия из исходных данных, например, в операциях отрицания. Порядок родительских понятий в секции *from* определяет порядок обхода дерева решений. Это дает возможность оптимизировать поиск решения, начав его с тех понятий, которые сильнее ограничивают пространство поиска.
Задача логического вывода — найти все возможные подстановки атрибутов дочернего понятия и каждую из них представить в виде объекта. Такие объекты считаются идентичными если совпадают имена их понятий, имена и значения атрибутов.
Допустимым считается создание нескольких понятий с одинаковым именем, но с разной реализацией, включая различный набор атрибутов. Это могут быть разные версии одного понятия, родственные понятия, которые удобно объединить под одним именем, одинаковые понятия из разных источников и т.п. При логическом выводе будут рассмотрены все существующие определения понятия, а результаты их поиска будут объединены. Несколько понятий с одинаковыми именами аналогичны правилу в языке Prolog, в котором список термов имеет дизъюнктивную форму (термы связаны операцией ИЛИ).
#### Наследование понятий
Одними из наиболее распространенных отношений между понятиями являются иерархические отношения, например «род-вид». Их особенностью является то, что структуры дочернего и родительского понятий будут очень близки. Поэтому поддержка механизма наследования на уровне синтаксиса очень важна, без нее программы будут переполнены повторяющимся кодом. При построении сети понятий было бы удобно повторно использовать как их атрибуты, так и отношения. Если список атрибутов легко расширять, сокращать или переопределять некоторые из них, то с модификацией отношений дело обстоит сложнее. Поскольку они представляют собой логическое выражение в конъюнктивной форме, то к нему легко прибавить дополнительные подвыражения. Но удаление или изменение может потребовать значительного усложнения синтаксиса. Польза от этого не так очевидна, поэтому отложим эту задачу на будущее.
Объявить понятие на основе наследования можно с помощью следующей конструкции:
```
concept <имя понятия> <псевдоним понятия> is
<имя родительского понятия> <псевдоним родительского понятия> (
<имя атрибута> = <выражение>,
...
),
...
with <имя атрибута> = <выражение>, ...
without <имя родительского атрибута>, ...
where <выражение отношений>
```
Секция *is* содержит список наследуемых понятий. Их имена можно указать напрямую в этой секции. Или же указать полный список родительских понятий в секции *from*, а в *is* — псевдонимы только тех из них, которые будут наследоваться:
```
concept <имя понятия> <псевдоним понятия> is
<псевдоним родительского понятия>,
…
from
<имя родительского понятия> <псевдоним родительского понятия> (
<имя атрибута> = <выражение>
...
),
…
with <имя атрибута> = <выражение>, ...
without <имя родительского атрибута>, ...
where <выражение отношений>
```
Секция *with* позволяет расширить список атрибутов наследуемых понятий или переопределить некоторые из них, секция *without* — сократить.
Алгоритм логического вывода понятия на основе наследования такой же, как и у понятия, рассмотренного выше. Разница только в том, что список атрибутов автоматически генерируется на основе списка атрибутов родительского понятия, а выражение отношений дополняется операциями равенства атрибутов дочернего и родительского понятий.
Рассмотрим несколько примеров использования механизма наследования. Наследование позволяет создать понятие на основе уже существующего избавившись от тех атрибутов, которые имеют смысл только для родительского, но не для дочернего понятия. Например, если исходные данные представлены в виде таблицы, то ячейкам определенных столбцов можно дать свои имена (избавившись от атрибута с номером столбца):
```
concept revenue is tableCell without columnNum where columnNum = 2
```
Также можно преобразовать несколько родственных понятий в одну обобщенную форму. Секция *with* понадобится для того, чтобы преобразовать часть атрибутов к общему формату и добавить недостающие. Например, исходными данными могут быть документы разных версий, список полей которых менялся со временем:
```
concept resume is resumeV1 with skills = 'N/A'
concept resume is resumeV2 r with skills = r.coreSkills
```
Предположим, что в первой версии понятия «Резюме» не было атрибута с навыками, а во второй он назывался по-другому.
Расширение списка атрибутов может потребоваться во многих случаях. Распространенными задачами являются смена формата атрибутов, добавление атрибутов, функционально зависящих от уже существующих атрибутов или внешних данных и т.п. Например:
```
concept price is basicPrice with valueUSD = valueEUR * getCurrentRate('USD', 'EUR')
```
Также можно просто объединить несколько понятий под одним именем не меняя их структуру. Например, для того чтобы указать, что они относятся к одному роду:
```
concept webPageElement is webPageLink
concept webPageElement is webPageInput
```
Или же создать подмножество понятия, отфильтровав часть его сущностей:
```
concept exceptionalPerformer is employee where performanceEvaluationScore > 0.95
```
Возможно также множественное наследование, при котором дочернее понятие наследует атрибуты всех родительских понятий. При наличии одинаковых имен атрибутов приоритет будет отдан тому родительскому понятию, которое находится в списке левее. Также можно решить этот конфликт вручную, явно переопределив нужный атрибут в секции `with`. Например, такой вид наследования был бы удобен, если нужно собрать в одной «плоской» структуре несколько связанных понятий:
```
concept employeeInfo is employee e, department d where e.departmentId = d.id
```
Наследование без изменения структуры понятий усложняет проверку идентичности объектов. В качестве примера рассмотрим определение *exceptionalPerformer*. Запросы к родительскому (*employee*) и дочернему (*exceptionalPerformer*) понятиям вернут одну и ту же сущность сотрудника. Объекты, представляющие ее, будут идентичны по смыслу. У них будет общий источник данных, одинаковый список и значения атрибутов, на разное имя понятия, зависящее от того, к какому понятию был выполнен запрос. Поэтому операция равенства объектов должна учитывать эту особенность. Имена понятий считаются равными, если они совпадают или связаны транзитивным отношением наследования без изменения структуры.
Наследование — это полезный механизм, позволяющий выразить явным образом такие отношения между понятиями как «класс-подкласс», «частное-общее», «множество-подмножество». А также избавиться от дублирования кода в определениях понятий и сделать код более понятным. Механизм наследования основан на добавлении/удалении атрибутов, объединении нескольких понятий под одним именем и добавлении условий фильтрации. Никакой специальной семантики в него не вкладывается, каждый может воспринимать и применять его как хочет. Например, построить иерархию от частного к общему как в примерах с понятиями *resume*, *price* и *webPageElement*. Или, наоборот, от общего к частному, как в примерах с понятиями *revenue* и *exceptionalPerformer*. Это позволит гибко подстроиться под особенности источников данных.
#### Понятие для описания отношений
Было решено, что для удобства понимания кода и облегчения интеграции компоненты моделирования с ООП моделью, отношения дочернего понятия с родительскими должны быть встроены в его определение. Таким образом, эти отношения задают способ получения дочернего понятия из родительских. Если модель предметной области строится слоями, и каждый новый слой основан на предыдущем, это оправдано. Но в некоторых случаях отношения между понятиями должны быть объявлены отдельно, а не входить в определение одного из понятий. Это может быть универсальное отношение, которое хочется задать в общем виде и применить к разным понятиям, например, отношение «Родитель-Потомок». Либо отношение, связывающее два понятия, необходимо включить в определение обоих понятий, чтобы можно было бы найти как сущности первого понятия при известных атрибутах второго, так и наоборот. Тогда, во избежание дублирования кода отношение удобно будет задать отдельно.
В определении отношения необходимо перечислить входящие в него понятия и задать логическое выражение, связывающее их между собой:
```
relation <имя отношения>
between <имя вложенного понятия> <псевдоним вложенного понятия> (
<имя атрибута> = <выражение>,
...
),
...
where <логическое выражение>
```
Например, отношение, описывающее вложенные друг в друга прямоугольники, можно определить следующим образом:
```
relation insideSquareRelation between square inner, square outer
where inner.xLeft > outer.xLeft and inner.xRight < outer.xRight
and inner.yBottom > outer.yBottom and inner.yUp < outer.yUp
```
Такое отношение, по сути, представляет собой обычное понятие, атрибутами которого являются сущности вложенных понятий:
```
concept insideSquare (
inner = i
outer = o
) from square i, square o
where i.xLeft > o.xLeft and i.xRight < o.xRight
and i.yBottom > o.yBottom and i.yUp < o.yUp
```
Отношение можно использовать в определениях понятий наряду с другими родительскими понятиями. Понятия, входящие в отношения, будут доступны извне и будут играть роль его атрибутов. Имена атрибутов будут соответствовать псевдонимам вложенных понятий. В следующем примере утверждается, что в HTML форму входят те HTML элементы, которые расположены внутри нее на HTML странице:
```
сoncept htmlFormElement is e
from htmlForm f, insideSquareRelation(inner = e, outer = f), htmlElement e
```
При поиске решения сначала будут найдены все значения понятия *htmlForm*, затем они будут связаны со вложенным понятием *outer* отношения *insideSquare* и найдены значения его атрибута *inner*. А в конце будут отфильтрованы те значения *inner*, которые относятся к понятию *htmlElement*.
Отношению можно придать и функциональную семантику — использовать его как функцию булева типа для проверки, выполняется ли отношение для заданных сущностей вложенных понятий:
```
сoncept htmlFormElement is e
from htmlElement e, htmlForm f
where insideSquareRelation(e, f)
```
В отличие от предыдущего случая, здесь отношение рассматривается как функция, что повлияет на порядок логического вывода. Вычисление функции будет отложено до того момента, когда все ее аргументы будут связаны со значениями. То есть, сначала будут найдены все комбинации значений понятий *htmlElement* и *htmlForm*, а затем отфильтрованы те из них, которые не соответствуют отношению *insideSquareRelation*. Более подробно об интеграции логической и функциональной парадигм программирования я планирую рассказать в одной из следующих публикаций.
#### Теперь пришло время рассмотреть небольшой пример
Определений фактов и основных видов понятий достаточно, чтобы реализовать пример с должниками из первой публикации. Предположим, что у нас есть два файла в формате CSV, хранящих информацию о клиентах (идентификатор клиента, имя и адрес электронной почты) и счетах (идентификатор счета, идентификатор клиента, дата, сумма к оплате, оплаченная сумма).
А также имеется некая процедура, которая считывает содержимое этих файлов и преобразовывает их в набор фактов:
```
fact cell {
table: “TableClients”,
value: 1,
rowNum: 1,
columnNum: 1
};
fact cell {
table: “TableClients”,
value: “John”,
rowNum: 1,
columnNum: 2
};
fact cell {
table: “TableClients”,
value: “john@somewhere.net”,
rowNum: 1,
columnNum: 3
};
…
fact cell {
table: “TableBills”,
value: 1,
rowNum: 1,
columnNum: 1
};
fact cell {
table: “TableBills”,
value: 1,
rowNum: 1,
columnNum: 2
};
fact cell {
table: “TableBills”,
value: 2020-01-01,
rowNum: 1,
columnNum: 3
};
fact cell {
table: “TableBills”,
value: 100,
rowNum: 1,
columnNum: 4
};
fact cell {
table: “TableBills”,
value: 50,
rowNum: 1,
columnNum: 5
};
```
Для начала дадим ячейкам таблиц осмысленные имена:
```
concept clientId is cell where table = “TableClients” and columnNum = 1;
concept clientName is cell where table = “TableClients” and columnNum = 2;
concept clientEmail is cell where table = “TableClients” and columnNum = 3;
concept billId is cell where table = “TableBills” and columnNum = 1;
concept billClientId is cell where table = “TableBills” and columnNum = 2;
concept billDate is cell where table = “TableBills” and columnNum = 3;
concept billAmountToPay is cell where table = “TableBills” and columnNum = 4;
concept billAmountPaid is cell where table = “TableBills” and columnNum = 5;
```
Теперь можно объединить ячейки одной строки в единый объект:
```
concept client (
id = id.value,
name = name.value,
email = email.value
) from clientId id, clientName name, clientEmail email
where id.rowNum = name.rowNum = email.rowNum;
```
```
concept bill (
id = id.value,
clientId = clientId.value,
date = date.value,
amountToPay = toPay.value,
amountPaid = paid.value
) from billId id, billClientId clientId, billDate date, billAmountToPay toPay, billAmountPaid paid
where id.rowNum = clientId.rowNum = date.rowNum = toPay.rowNum = paid.rowNum;
```
Введем понятия «Неоплаченный счет» и «Должник»:
```
concept unpaidBill is bill where amountToPay > amountPaid;
concept debtor is client c where exist(unpaidBill {clientId: c.id});
```
Оба определения используют наследование, понятие *unpaidBill* является подмножеством понятия *bill*, *debtor* — понятия *client*. Определение понятия *debtor* содержит вложенный запрос к понятию *unpaidBill*. Подробно механизм вложенных запросов мы рассмотрим позже в одной следующих публикаций.
В качестве примера «плоского» понятия определим также понятие «Долг клиента», в котором объединим некоторые поля из понятия «Клиент» и «Счет»:
```
concept clientDebt (
clientName = c.name,
billDate = b.date,
debt = b. amountToPay – b.amountPaid
) from unpaidBill b, client c(id = b.client);
```
Зависимость между атрибутами понятий *client* и *bill* вынесена в секцию *from*, а зависимости дочернего понятия *clientDebt* — в секцию его атрибутов. При желании все они могут быть помещены в секцию *where* — результат будет аналогичным. Но с моей точки зрения текущий вариант более краток и лучше подчеркивает назначение этих зависимостей — определять связи между понятиями.
Теперь попробуем определить понятие злостного неплательщика, который имеет как минимум 3 неоплаченных счета подряд. Для этого понадобится отношение, позволяющее упорядочить счета одного клиента по их дате. Универсальное определение будет выглядеть следующим образом:
```
relation billsOrder between bill next, bill prev
where next.date > prev.date and next.clientId = prev.clientId and not exist(
bill inBetween
where next.clientId = inBetween.clientId
and next.date > inBetween.date > prev.date
);
```
В нем утверждается, что два счета идут подряд, если они принадлежат одному клиенту, дата одного больше даты другого и не существует другого счета, лежащего между ними. На данном этапе я не хочу останавливаться на вопросах вычислительной сложности такого определения. Но если, например, мы знаем, что все счета выставляются с интервалом в 1 месяц, то можно его значительно упростить:
```
relation billsOrder between bill next, bill prev
where next.date = prev.date + 1 month and next.clientId = prev.clientId;
```
Последовательность из 3х неоплаченных счетов будет выглядеть следующим образом:
```
concept unpaidBillsSequence (clientId = b1.clientId, bill1 = b1, bill2 = b2, bill3 = b3)
from
unpaidBill b1,
billsOrder next1 (next = b1, prev = b2)
unpaidBill b2
billsOrder next2 (next = b2, prev = b3)
unpaidBill b3;
```
В этом понятии сначала будет найдены все неоплаченные счета, затем для каждого из них с помощью отношения *next1* будет найден следующий счет. Понятие *b2* позволит проверить, что этот счет является неоплаченным. По этому же принципу с помощью *next2* и *b3* будет найден и третий неоплаченный счет подряд. Идентификатор клиента вынесен в список атрибутов отдельно, чтобы в дальнейшем облегчить связывание этого понятия с понятием клиентов:
```
concept hardCoreDefaulter is client c where exist(unpaidBillsSequence{clientId: c.id});
```
Пример с должниками демонстрирует, как модель предметной области может быть полностью описана в декларативном стиле. По сравнению с реализацией этого примера в ООП или функциональном стиле получившийся код очень краток, понятен и близок к описанию задачи на естественном языке.
#### Краткие выводы.
Итак, я предложил три основных вида понятий компоненты моделирования гибридного языка:
* понятия, созданные на основе трансформации других понятий;
* понятия, наследующие структуру и отношения других понятий;
* понятия, задающие отношения между другими понятиями.
Эти три вида понятий имеют разную форму и назначение, но внутренняя логика поиска решений у них одинакова, различается только способ формирования списка атрибутов.
Определения понятий напоминают SQL запросы — как по форме, так и по внутренней логике исполнения. Поэтому я надеюсь, что предложенный язык будет понятен разработчикам и иметь относительно низкий порог входа. А дополнительные возможности, такие как использование понятий в определениях других понятий, наследование, вынесенные отношения и рекурсивные определения позволят выйти за рамки SQL и облегчат структурирование и повторное использование кода.
В отличии от языков RDF и OWL, компонента моделирования не делает различия между понятиями и отношениями — все является понятиями. В отличии от языков фреймовой логики — фреймы, описывающие структуру понятия, и правила, задающие связи между ними, объединены вместе. В отличии от традиционных языков логического программирования, таких как Prolog — основным элементом модели являются понятия, имеющие объектно-ориентированную структуру, а не правила, имеющие плоскую структуру. Такой дизайн языка может быть не так удобен для создания масштабных онтологий или набора правил, но зато гораздо лучше подходит для работы со слабоструктурированными данными и для интеграции разрозненных источников данных. Понятия компоненты моделирования близки к классам ООП модели, что должно облегчить задачу включения декларативного описания модели в код приложения.
Описание компоненты моделирования еще не закончено. В следующей статье я планирую обсудить такие вопросы из мира компьютерной логики как логические переменные, отрицание и элементы логики высших порядков. А после этого — вложенные определения понятий, агрегирование и понятия, которые генерируют свои сущности с помощью заданной функции.
Полный текст в научном стиле на английском языке доступен по ссылке: [papers.ssrn.com/sol3/papers.cfm?abstract\_id=3555711](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3555711)
Ссылки на предыдущие публикации:
[Проектируем мульти-парадигменный язык программирования. Часть 1 — Для чего он нужен?](https://habr.com/ru/post/521158/)
[Проектируем мульти-парадигменный язык программирования. Часть 2 — Сравнение построения моделей в PL/SQL, LINQ и GraphQL](https://habr.com/ru/post/522530/)
[Проектируем мульти-парадигменный язык программирования. Часть 3 — Обзор языков представления знаний](https://habr.com/ru/post/526410/) | https://habr.com/ru/post/530062/ | null | ru | null |
# Установка Linux на калькулятор. Часть II
[](https://habr.com/ru/company/ruvds/blog/542756/)
Как вы помните, в [прошлой статье](https://habr.com/ru/company/ruvds/blog/542388/) мне удалось стартануть linux на калькуляторе. Однако, работать на нём было невозможно, и я считаю это незачётом. Тогда я понял, что кроличья нора достаточно глубока и придётся полностью пересобирать всю систему, разбираясь с кодом. В итоге, я кратко прошёлся по всем этапам, которые описывал автор проекта. И результат полностью того стоит. Итак, поехали!
Аппаратные доработки: подключаем UART
-------------------------------------
Я написал обо всех моих бедах создателю этого linux, заодно попросив прислать мне бекап его прошивки (хотя его лучше, не заливать). И спросил, как же мне подключить UART к моему калькулятору? На что он мне прислал следующую картинку, и сказал: ищи это на другой стороне платы.
В результате, мне предстоял сложный квест — отклеить плату от дисплея, не расколов дисплей и не сломав плату. Пихая туда все возможные металлические предметы, очень аккуратно, в течении часа мне удалось её отделить. Самое сложное было не оборвать тончайшие шлейфы.
*Отделяем плату.*
Наконец-то, нашему вниманию представляется просто невероятный зоопарк тестовых падов, выводы JTAG и, по моему, SPI, интерфейс SD. Но, самое главное, наш отладочный UART.
Скорее всего там использована логика 1,8 В, но у меня не было такого адаптера, и я решил рискнуть и использовать адаптер с логикой 3,3 В (вам же настоятельно рекомендую использовать 1,8). Попытка, заставить мой адаптер работать на напряжении 1,8 вольта, не увенчалась успехом. Таким образом, я вывел сигналы на гребёнку, в т.ч. опорные 1,8 вольта (но они не пригодились).
*Можно приклеивать плату обратно и продолжать работать.*
Давайте сразу посмотрим, почему же у нас не запускается система, при загрузке в ОЗУ? Хотя вроде всё работает. Во-первых, давайте глянем скрипт запуска. Содержимое файла *run\_linux\_in\_ram.uu*:
```
uuu_version 1.2.135
# This script allows you to run the Linux OS in the RAM without altering the NAND Flash
SDP: boot -f boot/u-boot-dtb.imx -nojump
SDP: write -f firmware/zImage -addr 0x80800000
SDP: write -f firmware/imx6ull-14x14-prime.dtb -addr 0x83000000
SDP: write -f firmware/rootfs.cpio.uboot -addr 0x86800000
SDP: jump -f boot/u-boot-dtb.imx -ivt
SDP: done
```
Загружаем в память загрузчик u-boot, ядро, dts (точнее, скомпилированный бинарник dtb), initramfs и передаём управление загрузчику, после чего с успехом завершаем приложение uuu.
По логам всё идёт отлично, до момента окончательной загрузки ядра, а там начинается вот такая петрушка.
```
clk: Not disabling unused clocks
ALSA device list:
No soundcards found.
Freeing unused kernel memory: 1024K
can't open /dev/null: No such file or directory
...
can't open /dev/null: No such file or directory
Starting syslogd: OK
Starting klogd: OK
Starting network: OK
Starting Xorg: OK
can't open /dev/ttymxc0: No such file or directory
....
can't open /dev/ttymxc0: No such file or directory
imx-sdma 20ec000.sdma: external firmware not found, using ROM firmware
input: Goodix Capacitive TouchScreen as /devices/soc0/soc/2100000.aips-bus/21a4000.i2c/i2c-1/1-0014/input/input3
```
И так до посинения. Всё банально, /dev/ не создана. И проблема эта открылась позже, при конфигурировании rootfs. Шикарно, мы теперь имеем отличный инструмент отладки. Начнём всё собирать!
Сборка софта
------------
Если вы дойдёте самостоятельно до этого этапа, то надеюсь у вас есть какой-никакой опыт сборки ядра, rootfs, конфигурирования через make menuconfig. Так как описывать весь необходимый список установочных пакетов мне уже лениво (надо установить как минимум кросскомпилятор arm-linux-gnueabihf-, ncurses и многое другое, у меня просто уже всё давно стоит). Будем считать, что вы всё умеете, я лишь заострю ваше внимание на некоторые моменты. Для начала процитирую, то как рекомендуется делать сборку на официальном сайте проекта, а потом я внесу некоторые комментарии.
> 4. Сборка из исходника
> ----------------------
>
>
>
> Этот процесс протестирован под Ubuntu 18.04 LTS. Рекомендуется делать сборку под Linux.
>
> ### 4.1 u-boot
>
>
>
> Как правило, пересобирать u-boot вам не нужно, и нижеприведенные инструкции даются в качестве справочного материала.
>
> Чтобы собрать u-boot из исходника:
>
>
>
>
> ```
> git clone git://github.com/zephray/uboot.git
> cd uboot
> git checkout imx_v2018.03_4.14.98_2.0.0_ga
> make mx6ull_prime_defconfig
> ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make
> ```
>
>
> В результате получится бинарный файл u-boot-dtb.imx.
>
>
>
> ### 4.2 Ядро
>
>
>
> Для включения/отключения конкретных модулей драйверов/ядра потребуется пересобрать все ядро.
>
>
>
> #### 4.2.1 Компиляция с помощью Buildroot
>
>
>
> buildroot соберет ядро автоматически. Конфигурацию же можно изменить с помощью make linux-menuconfig.
>
>
>
> #### 4.2.2 Сборка ядра вручную
>
>
>
>
> ```
> git clone git://github.com/zephray/linux.git
> cd linux
> git checkout imx_4.14.98_2.0.0_ga
> ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make hp_prime_defconfig
> ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make
> ```
>
>
> В итоге будут собраны файлы arch/arm/boot/dts/imx6ull-14x14-prime.dts и arch/arm/boot/zImage.
>
>
>
> ### 4.3 Корневая файловая система (rootfs)
>
>
>
> На данный момент hp-prime-linux использует для построения корневой файловой системы buildroot. Пакетного менеджера пока что нет, и если вам нужно добавить или удалить пакет, то потребуется пересобрать rootfs.
>
>
>
>
> ```
> git clone git://git.buildroot.net/buildroot
> cd buildroot
> git checkout 2019.02.4
> make BR2_EXTERNAL=~/Prinux/buildroot prime_defconfig
> make
> ```
>
>
> Для установки модулей ядра в rootfs, перейдите в директорию ядра и выполните следующие команды:
>
>
>
>
> ```
> INSTALL_MOD_PATH=~/buildroot/output/target ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make modules_install
>
> ```
>
>
> После этого повторно сгенерируйте образы с помощью buildroot.
>
>
Для начала, я решил проверить, что, как минимум, всё это собирается из исходников, поэтому решил потренироваться на самом простом — сборке u-boot. Это важно, так как бывает такой момент, что автор написал инструкцию по сборке и прошивке, а забыл закоммитить последние изменения, и в результате его инструкция оказывается бесполезным мусором.
U-boot собирается совершенно 1 в 1 по инструкции, без каких либо тонкостей. В корневой папке после компиляции, мы получим кучу файлов, но нас интересует файл u-boot-dtb.imx.
Скопируем его в нашу флеш-утилиту (предварительно создав там папку my):
```
cp u-boot-dtb.imx /home/dlinyj/tmp/calc/flash_utility/my
```
И создадим там новый загрузочный скрипт, на котором всё и будем обкатывать:
```
uuu_version 1.2.135
SDP: boot -f my/u-boot-dtb.imx -nojump
SDP: jump -f my/u-boot-dtb.imx -ivt
SDP: done
```
Проверяем на калькуляторе (всё как обычно, запускаем скрипт, потом вставляем USB. И в результате должны получить такой результат.
Это полный успех, значит код рабочий и мы можем продолжать. Если вы дойдёте до сборки, то настоятельно рекомендую поглядеть git log и git diff между коммитами, чтобы оценить масштабы проделанной работы. Это восхищает и мотивирует!
Со сборкой ядра у меня тоже практически не возникло никаких проблем, разве что пришлось поставить дополнительный пакет lzop, чтобы ядро корректно сжалось. Протестировать можно точно так же (не забыв добавить загрузку dtb-файла, иначе ядро не стартанёт).
Самым сложным оказалась сборка rootfs, как оказалось, дефолтный конфиг мне не подойдёт для сборки. Для начала. делаем всё точно, как написано в инструкции:
```
git clone git://git.buildroot.net/buildroot
cd buildroot
git checkout 2019.02.4
```
А вот теперь начинается самое интересное, хождение по битым ссылкам :). В [релизах](https://github.com/zephray/prinux/releases), кроме flash\_utility.tar.gz есть ещё файл Source code, который, совершенно неочевидным образом содержит в себе необходимые конфиги для сборки rootfs! Скачиваем файл prinux-0.1.zip и распаковываем его в удобное для нас место. Либо клонируем [репозиторий](https://github.com/zephray/prinux). У меня это вышел путь /home/dlinyj/tmp/calc/prinux.
Там внутри есть папка buildroot — это и есть внешние конфигурационные файлы для сборки buildroot! И вот этот путь, именно до этой папки указываем в следующей команде:
```
make BR2_EXTERNAL= /home/dlinyj/tmp/calc/prinux prime_defconfig
```
Допереть до этого самостоятельно было невозможно, покуда я не прошерстил вообще все репозитории, файлы и не прочитал как же собирается buildroot (к своему стыду, впервые собираю его вот так, с нуля).
Этой конфигурации мало, в целом можно конечно собрать, и даже попробовать запустить, но initramfs он будет слишком здоровым (там стоят Иксы), больше 25 МБ, и он не запустится. А для прошивки на nand мы будем получать ту же самую проблему, как и в тесте загрузки в память: не будут созданы файл-устройства.
Первое, я отредактировал файл */home/dlinyj/tmp/calc/prinux/buildroot/configs/prime\_defconfig* и привёл его к виду:
```
BR2_arm=y
BR2_cortex_a7=y
BR2_ARM_FPU_NEON_VFPV4=y
BR2_OPTIMIZE_3=y
BR2_TOOLCHAIN_EXTERNAL=y
BR2_TARGET_GENERIC_HOSTNAME="prinux"
BR2_TARGET_GENERIC_ISSUE="Welcome to Prinux"
BR2_INIT_SYSTEMD=y
BR2_TARGET_GENERIC_GETTY_PORT="ttymxc0"
BR2_ROOTFS_OVERLAY="$(BR2_EXTERNAL_PRINUX_PATH)/board/prime/overlay/"
BR2_ROOTFS_POST_IMAGE_SCRIPT="$(BR2_EXTERNAL_PRINUX_PATH)/board/prime/post_build.sh"
BR2_TARGET_ROOTFS_TAR_BZIP2=y
BR2_PACKAGE_HOST_UBOOT_TOOLS=y
```
Выкинув совершенно лишние на данный момент пакеты иксов (мне бы стартануть систему, а потом всё остальное).
Далее выполняю:
```
make BR2_EXTERNAL= /home/dlinyj/tmp/calc/prinux prime_defconfig
make menuconfig
```
В опции Filesystem images включаю:
```
[*] cpio the root filesystem (for use as an initial RAM filesystem)
[*] Create U-Boot image of the root filesystem
```
Прохожусь по всем пакетам и отрубаю вообще всё, чтобы не было лишнего.
В разделе System configuration ставлю:
```
Init system (BusyBox)
/dev management (Static using device table)
```
Тем самым ещё более уменьшая образ, и наконец у нас будет корректно работать менеджер устройств!
Выходим и сохраняем. И собираем:
```
make
```
После успешной компиляции, топаем обратно в папку с собранным ядром и нам необходимо теперь установить модули ядра в нашу rootfs, для этого выполняем:
```
INSTALL_MOD_PATH=/home/dlinyj/tmp/calc/buildroot/output/target ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make modules_install
```
И возвращаемся в buildroot и вновь выполняем make. В результате мы получим собранные пакеты в папке /home/dlinyj/tmp/calc/buildroot/output/images:
* **rootfs.cpio.uboot** — это готовый initramfs
* **rootfs.tar.bz2** — образ готовый для прошивки на nand.
Стартуем!
---------
Переписываю готовые образы rootfs в папку my и не забываем переписать туда же свежесобранное ядро из папки /home/dlinyj/tmp/calc/linux/arch/arm/boot, файл zImage. Далее беру за основу скрипт прошивки на nand-флеш и привожу его к виду:
**Скрипт для прошивки на nand-flash**
```
uuu_version 1.2.135
# This script allows you to flash the Linux OS into NAND Flash.
# Boot into flash environment
SDP: boot -f boot/u-boot-dtb.imx -nojump
SDP: write -f boot/zImage -addr 0x80800000
SDP: write -f boot/imx6ull-14x14-prime.dtb -addr 0x83000000
SDP: write -f boot/fsl-image-mfgtool-initramfs-imx_mfgtools.cpio.gz.u-boot -addr 0x86800000
SDP: jump -f boot/u-boot-dtb.imx -ivt
# Flash kernel
FBK: ucmd flash_erase /dev/mtd1 0 0
FBK: ucp my/zImage t:/tmp
FBK: ucmd nandwrite -p /dev/mtd1 /tmp/zImage
# Flash device tree blob
FBK: ucmd flash_erase /dev/mtd2 0 0
FBK: ucp firmware/imx6ull-14x14-prime.dtb t:/tmp
FBK: ucmd nandwrite -p /dev/mtd2 /tmp/imx6ull-14x14-prime.dtb
# Flash rootfs
FBK: ucmd flash_erase /dev/mtd4 0 0
FBK: ucmd ubiformat /dev/mtd4
FBK: ucmd ubiattach /dev/ubi_ctrl -m 4
FBK: ucmd ubimkvol /dev/ubi0 -Nrootfs -m
FBK: ucmd mkdir -p /mnt/mtd
FBK: ucmd mount -t ubifs ubi0:rootfs /mnt/mtd
FBK: acmd export EXTRACT_UNSAFE_SYMLINKS=1; tar -jx -C /mnt/mtd
FBK: ucp my/rootfs.tar.bz2 t:-
FBK: sync
FBK: ucmd umount /mnt/mtd
# Done
FBK: done
```
Обращаю внимание, что у нас используется специальный образ rootfs для прошивки nand-флеш. Я выкинул прошивку u-boot (так и не понял в чём проблема, и пока не смог победить). device tree blob загружается из другой папки, но никто не мешает его собранный так же переписать либо из u-boot, либо из папки с ядром.
Запускаем этот скрипт, и у нас успешно прошивается nand-флеш. Поскольку загрузчик у нас не прошит, при подаче питания linux не стартанёт. Поэтому вновь правим (или пишем новый скрипт) для загрузки u-boot:
```
uuu_version 1.2.135
SDP: boot -f my/u-boot-dtb.imx -nojump
SDP: jump -f my/u-boot-dtb.imx -ivt
SDP: done
```
Запускаем этот скрипт, и шалость удалась!
К сожалению, мне удалось успешно загрузиться на nand только один раз, потом я решил поправить один файл и у меня уже сыпалось всё с паникой ядра. Чуть ниже расскажу о проблемах.
А как на счёт логина с клавиатуры калькулятора и работы экрана?
---------------------------------------------------------------
А, вы хотите нормальной работы калькулятора, прям как настоящего компьютера? Независимо от большого ПК, не работая через консоль? Да?
Да ладно. Их есть у меня, пожалуйста. Для этого, согласно той же инструкции надо поправить один файл. Цитирую:
> ### 5.3.1 Активация консоли VT
>
>
>
> В данном релизе она активна по умолчанию.
>
>
>
>
> ```
> vi ~/buildroot/output/target/etc/inittab
> ```
>
>
> Введите следующее:
>
>
>
>
> ```
> tty0::respawn:/sbin/getty -L tty0 0 vt100 # VT
> ```
>
Хочу обратить внимание, что в оригинальной статье ошибка (забыт нолик), в этой цитате я исправил данную команду. Вписываем эту строку, и перекомпилируем снова rootfs.
Далее пишем загрузочный скрипт, для загрузки нашей сборки initramfs:
```
uuu_version 1.2.135
# This script allows you to run the Linux OS in the RAM without altering the NAND Flash
SDP: boot -f my/u-boot-dtb.imx -nojump
SDP: write -f my/zImage -addr 0x80800000
SDP: write -f firmware/imx6ull-14x14-prime.dtb -addr 0x83000000
SDP: write -f my/rootfs.cpio.uboot -addr 0x86800000
SDP: jump -f my/u-boot-dtb.imx -ivt
SDP: done
```
Запускаем его, и вот вам демонстрация работы экрана и клавиатуры, ну чем не компьютер.
После чего я немного разошёлся, и накидал ещё в /root несколько графических файлов, и вывел их с помощью программы fbi (вы их видели в заходниках статей).
Итого
-----
Фух, была проделана громадная работа, растянувшаяся на две недели, но оно того по настоящему стоило!
Если, вы вдруг имеете подобный калькулятор, то вполне можете повторить запуск линукс (как минимум в ОЗУ), с помощью обновленной утилиты, которую можете скачать вот тут.
[flash\_utility.tar.gz](https://disk.yandex.ru/d/KpEZWBjFVaLDQg).
К сожалению, с nand-флеш мне не удалось подружиться. После редактирования файлика, и дальнейшей перезагрузки, я получил вот такое сообщение.
Я так и не понял почему так получается, как я не бился, второй раз загрузиться на nand-флеш мне не удалось. Скорее всего, это связанно с тем, что я затёр вспомогательные области nand-флеша, и где-то rootfs и u-boot попадает на эти битые сектора, которые я варварским образом перемаркировал в нормальные. Уже буквально в ночи, перед выходом данной статьи решил собрать initramfs с утилитами mtd и nand и посмотреть, что же происходит. А происходит весьма любопытная петрушка. При загрузке ядро у меня выдаёт.
```
gpmi-nand 1806000.gpmi-nand: mode:4 ,failed in set feature.
Bad block table found at page 262080, version 0x01
Bad block table found at page 262016, version 0x01
nand_read_bbt: bad block at 0x000000000000
nand_read_bbt: bad block at 0x000000020000
nand_read_bbt: bad block at 0x000000040000
nand_read_bbt: bad block at 0x000000060000
nand_read_bbt: bad block at 0x0000012c0000
nand_read_bbt: bad block at 0x000004e20000
nand_read_bbt: bad block at 0x000005280000
nand_read_bbt: bad block at 0x0000094c0000
nand_read_bbt: bad block at 0x000017b20000
5 cmdlinepart partitions found on MTD device gpmi-nand
Creating 5 MTD partitions on "gpmi-nand":
0x000000000000-0x000000400000 : "boot"
0x000000400000-0x000000c00000 : "kernel"
0x000000c00000-0x000000d00000 : "dtb"
0x000000d00000-0x000000e00000 : "misc"
0x000000e00000-0x000020000000 : "rootfs"
gpmi-nand 1806000.gpmi-nand: driver registered.
```
Но при этом в системе пятый раздел, на котором собственно и находится rootfs после загрузки отсутствует. Ошибок в логе загрузки нет:
```
# mtdinfo
Count of MTD devices: 5
libmtd: error!: cannot open "/dev/mtd4"
error 2 (No such file or directory)
Present MTD devices: mtd0, mtd1, mtd2, mtd3, mtd4
Sysfs interface supported: yes
# ls -la /dev/mtd*
crw-r----- 1 root root 90, 0 Feb 16 2021 /dev/mtd0
crw-r----- 1 root root 90, 2 Feb 16 2021 /dev/mtd1
crw-r----- 1 root root 90, 4 Feb 16 2021 /dev/mtd2
crw-r----- 1 root root 90, 6 Feb 16 2021 /dev/mtd3
brw-r----- 1 root root 31, 0 Feb 16 2021 /dev/mtdblock0
brw-r----- 1 root root 31, 1 Feb 16 2021 /dev/mtdblock1
brw-r----- 1 root root 31, 2 Feb 16 2021 /dev/mtdblock2
brw-r----- 1 root root 31, 3 Feb 16 2021 /dev/mtdblock3
```
Странная, пока непонятная мистика, куда подевался раздел.
Точно так же, мне не удалось прошить u-boot на nand. При прошивке командой:
```
kobs-ng init -x -v --chip_0_device_path=/dev/mtd0 /tmp/u-boot-dtb.imx
```
Происходит следующая ошибка:
```
WOpen:/tmp
WOpen:/tmp/u-boot-dtb.imx
run shell cmd: kobs-ng init -x -v --chip_0_device_path=/dev/mtd0 /tmp/u-boot-dtb.imx
unable to create a temporary file
```
Это всё, что удалось поймать по UART. Я уже и в исходниках kobs-ng поковырялся, но всё бестолку. Пока непонятно как разрешить этот вопрос.
Вопросы к сообществу
--------------------
* Кто-нибудь сталкивался с проблемой перепрошивки с помощью утилиты kobs-ng?
Благодарности
-------------
* Выражаю огромную благодарность создателю данного проекта [ZephRay](https://github.com/zephray/), без него бы этой статьи бы не было. Это невероятный и очень крутой труд.
* Выражаю благодарность [Bright\_Translate](https://habr.com/ru/users/bright_translate/) за помощь с переводом инструкции по установке.
* Главная благодарность моей жене, которая помогала мне в составлении и оформлении данной статьи. А так же терпела мои ночные бдения за этим устройством.
Ссылки
------
1. [Основной проект.](https://www.zephray.me/post/hp_prime_g2_linux)
2. [Файлы для сборки rootfs и скрипты прошивальщика.](https://github.com/zephray/prinux/releases)
3. [Обновлённая мной рабочая прошивка для калькулятора.](https://disk.yandex.ru/d/KpEZWBjFVaLDQg)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=ustanovka_linux_na_kalkulyator_2#order) | https://habr.com/ru/post/542756/ | null | ru | null |
# Интерактивный пол на Android
Наверное, многие из вас видели интерактивные игры для детей в торговых центрах. Где динамическая сцена проецируется на пол, а рядом установленный сенсор определяет точки касания с поверхностью и преобразует их в события для приложения на управляющем компьютере. После поиска в интернете информации об этом устройстве оказалось, что это довольно дорогая игрушка. Например, китайские клоны стартуют с ценника в $1200, а что-то более оригинальное стоит уже $10 тыс. После анализа технической составляющей продукта было решено сделать аналогичное устройство самому.
Железо проекта состоит из трех частей:
* Сенсор глубины (в оригинале это ASUS Xtion);
* Управляющий компьютер (Cubieboard A80, ODROID-U3);
* Проектор.
В идеале все железки вместе не должны стоить больше 700 долларов. Предполагалось, что соединить все три части должно быть относительно легко, так как в интернете есть такие библиотеки, как OpenNI и libfreenect, которые работают и на Android, и на Linux. Из-за недостатка опыта на раннем этапе казалось, что есть выбор и в железе, и в ОС; есть примеры открытого кода и соединить все вместе не составит большого труда. Через некоторое время после начала проекта оказалось, что это не так. Интеграция всех частей и даже запуск библиотек на целевом устройстве есть самая сложная задача. Пришлось выбирать между доступностью информации по настройке Linux и обилием приложений в маркете под платформу Android.
Однако, обо всем по порядку.
Для того, что бы сразу начать экспериментировать с железом, был куплен б/у сенсор Microsoft Kinect и проектор. Затем из квадратной профилированной трубы изготовлено вот такое крепление для проектора и сенсора:
В верхней части крепления приварен небольшой кусок уголка для монтажа к потолку. В местах изгибов трубы для усиления конструкции приварены пластинки в виде косынок. Проектор соединяется с креплением через треугольную пластину из фанеры. Для соединения сенсора с креплением используется специальный аксессуар для Kinect, который можно без проблем найти на ebay. В качестве управляющего компьютера для удешевления была выбрана плата [Cubieboard A10](http://upload.wikimedia.org/wikipedia/commons/2/24/Cubieboard.jpeg), которую также без проблем можно найти на ebay. На момент написания статьи уже вышли Cubieboard A20 и A80, соответственно двух и восьми-ядерные аналоги. Если позволяет бюджет, то желательно купить A80, чтобы у системы был запас мощности для одновременной работы пользовательских приложений и сервиса по захвату и обработке данных от сенсора глубины. За питание платы и сенсора отвечает [USB блок питания](http://i.ebayimg.com/00/s/MTUwMFgxNTAw/z/OU0AAOSwpDdU2b9c/$_57.JPG) с выходным током на 4A. Проектор и сенсор соединяются с креплением так, что бы камера глубины была в одной плоскости с объективом проектора:
Модель проектора лучше выбрать такую, чтобы картинка получалась максимально большой с малого расстояния. На этом описание железной части можно закончить. Теперь о программном обеспечении.
В качестве операционной системы была выбрана сборка Android под Cubieboard с забавной [заставкой](http://cubieboard.org/wp-content/uploads/2014/01/androidv101.jpg) на рабочем столе. Мне пришлось немного подправить файлы конфигурации и скомпилировать сборку самому из-за того, что в Android нельзя изменить последовательность загрузки модулей, точнее можно, но до следующей перезагрузки системы.
Для внедрения событий потребовался модуль драйвера сенсорного экрана sun4i-ts. На самом деле, тестовое приложение реализует TUIO клиент, но, как оказалось, даже с драйвером сенсорной панели существующий под Android сервер TUIO не поддерживает multitouch события. Возможно, это связано с самим драйвером сенсорной панели sun4i-ts под Allwinner. Исходя из этих фактов был выбран вариант с прямым внедрением событий.
Для захвата данных о глубине используется легковесная и быстрая библиотека libfreenect, которая, в свою очередь, использует libusb для передачи данных по USB. Полученные данные о глубине обрабатываются с помощью OpenCV для Android. Суть обработки довольно простая: карту глубины необходимо преобразовать в замкнутые контуры с длиной не меньше, чем пороговая, для исключения ложных срабатываний — и найти их геометрические центры.
В самом начале работы, когда на сцене нет ни одного объекта, приложение строит карту глубины фона, затем в процессе работы карта используется для отделения целевых объектов от фона. Приложение представляет собой управляющую часть и сервис с кодом на С/C++. Вся логика обработки и захвата данных о глубине реализована на С/C++. Часть кода по работе с TUIO и OpenCV была взята из этого [проекта](https://github.com/robbeofficial/KinectTouch) на github.
Рассмотрим код более подробно. В коде, как я уже говорил, используется OpenCV. В самом начале работы приложение строит карту глубины:
```
1 void STouchDetector::process(const uint16_t& depthData) {
2 frmCount++;
3 // create background model (average depth)
4 if (frmCount < BackgroundTrain) {
5 depth.data = (uchar*)(&depthData);
6 buffer[frmCount] = depth;
7 }
8 else {
9 if (frmCount == BackgroundTrain) {
10 // Calculate average depth based on all frames from buffer
11 average(buffer, background);
12 Scalar bmeanVal = mean(background(roi));
13 double bminVal = 0.0, bmaxVal = 0.0;
14 minMaxLoc(background(roi), &bminVal, &bmaxVal);
15 LOGD("Background extraction completed. Average depth is %f min %f max %f", bmeanVal.val[0], bminVal, bmaxVal);
16 }
```
В строке 6 данные о глубине сохраняются в буфере. Следует отметить, что буфер имеет тип std::vector. Это массив из матриц и присваивание в строке 6 — это фактически копирование всех пикселей кадра в буфер. После достижения счетчиком кадров порогового значения BackgroundTrain вызывается функция подсчета среднего значения глубины по всем кадрам в строке 11:
```
1 void STouchDetector::average(vector& frames, Mat1s& mean) {
2 Mat1d acc(mean.size());
3 Mat1d frame(mean.size());
4 for (unsigned int i=0; i
```
В функции выше происходит преобразование матрицы двухбайтовых целых в матрицу чисел с плавающей точкой, затем происходит сложение с матрицой аккумулятором и, в конце, вычисляется среднее. В строке 8 операция деления производится для каждого элемента матрицы.
В следующей части кода выделяются объекты с помощью ранее созданного фона глубины в строке 4. Затем с помощью функции OpenCV findContours() выделяются контуры. Для контуров с длиной больше пороговой подсчитывается их геометрический центр. Координаты полученных центров добавляются в массив touchPoints, который хранит координаты событий нажатия на поверхность:
```
1 // Update 16 bit depth matrix
2 depth.data = (uchar*)(&depthData);
3 // Extract foreground by simple subtraction of very basic background model
4 foreground = background - depth;
5
6 // Find touch mask by thresholding (points that are close to background = touch points)
7 touch = (foreground > TouchDepthMin) & (foreground < TouchDepthMax);
8
9 // Extract ROI
10 Mat touchRoi = touch(roi);
11
12 // Find contours by depth data
13 vector< vector > contours;
14 vector touchPoints;
15 findContours(touchRoi, contours, CV\_RETR\_LIST, CV\_CHAIN\_APPROX\_SIMPLE, Point2i(xMin, yMin));
16
17 for (unsigned int i=0; i < contours.size(); i++) {
18 Mat contourMat(contours[i]);
19 // Find touch points by area thresholding
20 if ( contourArea(contourMat) > ContourAreaThreshold ) {
21 Scalar center = mean(contourMat);
22 Point2i touchPoint(center[0], center[1]);
23 touchPoints.push\_back(touchPoint);
24 }
25 }
```
В последней части происходит отправка событий в систему. Координаты для событий нажатия на поверхность берутся из ранее созданного массива touchPoints.
```
1 // Send TUIO cursors
2 tuioTime = TuioTime::getSessionTime();
3 tuio->initFrame(tuioTime);
4
5 for (unsigned int i=0; i < touchPoints.size(); i++) { // touch points
6 float cursorX = (touchPoints[i].x - xMin) / (xMax - xMin);
7 float cursorY = 1 - (touchPoints[i].y - yMin) / (yMax - yMin);
8 TuioCursor* cursor = tuio->getClosestTuioCursor(cursorX,cursorY);
9
10 LOGD("Touch detected %d %d", (int)touchPoints[i].x, (int)touchPoints[i].y);
11
12 // TODO improve tracking (don't move cursors away, that might be closer to another touch point)
13 if (cursor == nullptr || cursor->getTuioTime() == tuioTime) {
14 tuio->addTuioCursor(cursorX,cursorY);
15 eventInjector->sendEventToTouchDevice((int)(touchPoints[i].x - xMin),
16 (int)(touchPoints[i].y - yMin));
17 LOGD("TUIO cursor was added at %d %d", (int)touchPoints[i].x, (int)touchPoints[i].y);
18 } else {
19 tuio->updateTuioCursor(cursor, cursorX, cursorY);
20 }
21 }
```
Для отправки событий в систему вызывается функция sendEventToTouchDriver(), а для отправки сообщения TUIO серверу функции addTuioCursor() и updateTuioCursor().
В конце обсуждения кода хотелось бы рассказать о модуле отправки событий системе. Модуль называется stouchEventInjector.cpp. В самом начале работы в конструкторе с помощью функции open() открывается файл событий устройства ввода /dev/input/eventX, где X — это число. Модуль сам пытается найти дескриптор, связанный с нужным драйвером (sun4i\_ts). Для этого последовательно вызывается функция getevent с ключем -pl для каждого существующего файла /dev/input/eventX. Отправка события, на самом деле, — это запись в файл /dev/input/eventX структуы uinput\_event с помощью функции write(). У тачскрина имеется своя система координат с максимальным и минимальным значением по осям, в случае с sun4i-ts максимальное число по обеим осям ох и оу равно 4095. Последовательность команд, которую нужно отправить для симуляции нажатия на тачскрин можно найти в исходниках в функции sendTouchDownAbs().
Для автоматического запуска драйвера тачскрина после старта устройства, как я говорил в начале, нужно изменить конфигурацию сборки Android. Для сборки Android последнюю версию Ubuntu в моем случае версия была 14.10. Исходный код берем отсюда [Cubieboard A10 Android](http://docs.cubieboard.org/tutorials/cb1/installation/building_android_ics_a10_image) и распаковываем. Нам необходимо изменить два файла:
```
android/device/softwinner/apollo-cubieboard/init.sun4i.rc
android/frameworks/base/data/etc/platform.xml
```
В файле init.sun4i.rc необходимо раскоментировать строку insmod /system/vendor/modules/sun4i-ts.ko. В файле platform.xml необходимо добавить группы usb, input и shell в секцию INTERNET:
```
```
После внесения изменений запускаем сборку командой:
```
./build.sh -p sun4i_crane -k 3.0
```
Для сборки версии Android ICS необходим компилятор GCC версии 4.6 и make версии 3.81. Если версия компилятора и make отличается от необходимой, то ее можно изменить командами:
```
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.6 60 --slave /usr/bin/g++ g++ /usr/bin/g++-4.6
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
sudo update-alternatives --config gcc
sudo mv /usr/bin/make /usr/bin/make40
sudo update-alternatives --install /usr/bin/make make /usr/local/bin/make 60
sudo update-alternatives --install /usr/bin/make make /usr/bin/make40 40
sudo update-alternatives --config make
```
Далее следуем инструкциям на странице [Cubieboard A10 Android](http://docs.cubieboard.org/tutorials/cb1/installation/building_android_ics_a10_image). В процессе сборки могут возникнуть ошибки компиляции. Подсказки для исправления ошибок можно найти в секции Fix building issues в файле fix\_android\_firmware.readme в репозитории с исходным кодом. Для подключения платы к ПК необходимо добавить правила для подключения устройства по USB для этого создаем файл:
```
/etc/udev/rules.d/51-android.rules
```
И добавляем следующую строку:
```
SUBSYSTEM=="usb", ATTRS{idVendor}=="18d1", ATTRS{idProduct}=="0003",MODE="0666"
```
Чтобы изменения вступили в силу, перезапускаем сервис udev:
```
$sudo chmod a+rx /etc/udev/rules.d/51-android.rules
$sudo service udev restart
```
Подключаем плату к ПК и заливаем образ прошивки sun4i\_crane\_cubieboard.img с помощью утилиты [LiveSuit](http://dl.cubieboard.org/software/tools/livesuit/LiveSuitV306_For_Linux64.zip). Перед установкой внимательно прочитайте инструкцию к LiveSuit, если установить неправильно, то приложение не сможет загрузить образ на устройство. После загрузки образа и перезапуска платы можно установить и запустить приложение SimpleTouch. Приложение автоматически запустит сервис, который захватывает/обрабатывает данные от Kinect и отправляет события системе. Приложение можно просто свернуть и запустить какую-нибудь игру из PlayMarket.
Исходный код можете скачать с [bitbucket](https://rdv0011@bitbucket.org/rdv0011/stouch_public).
Видео демонстрации работы: | https://habr.com/ru/post/256143/ | null | ru | null |
# Firefox и RamDisk. Автоматизация, бэкап и автообновление
После написания [топика](http://habrahabr.ru/blogs/google_chrome/70926/) об использовании Google Chrome на рамдиске, я получил несколько просьб сделать то же самое и для Firefox.
Итак… Спустя неделю тестов, выкладываю готовый рецепт по использованию Фокса на рамдиске.
#### Установка
Нам опять же потребуются:
[nnCron](http://www.nncron.ru/download/nncron193b8.exe), [nnBackup](http://www.nncron.ru/download/nnbackup228.exe) (обязательно зарегистрировать!), [WinRAR](http://www.rarlab.com/rar/wrar390ru.exe), [Gavotte Ramdisk](http://www.mydigitallife.info/2007/05/27/free-ramdisk-for-windows-vista-xp-2000-and-2003-server/), [Wget](http://downloads.sourceforge.net/gnuwin32/wget-1.11.4-1-setup.exe), побольше оперативки.
Всё это добро устанавливаем, и создаём рамдиск R:\.
#### Подготовка
Для начала, Фокс надо закрыть :)
В адресной строке проводника пишем: %AppData%\Mozilla\Firefox\Profiles, жмём Enter и открываем папку со своим профилем.
Копируем из папки с профилем все файлы в D:\Backup\Firefox\Profile.
Открываем файл %AppData%\Mozilla\Firefox\profiles.ini, удаляем оттуда всё, и вставляем такой текст:
[General]
StartWithLastProfile=1
[Profile0]
Name=Default User
IsRelative=0
Path=R:\Firefox\Profile
Default=1
(хотя можно и не вставлять, скрипт это сделает сам через некоторое время)
Всё, профиль успешно перенесён.
Немного настроек в файле user.js:
`// Кэш и память
user_pref("browser.cache.disk.enable", true); // дисковый кэш нам нужен..
user_pref("browser.cache.disk.capacity", 65535); // ..и ограничим мы его 64 мегабайтами. можно больше, если оперативки не жалко :)
user_pref("browser.cache.memory.enable", false); // кэш в памяти теряет смысл
user_pref("browser.cache.offline.enable", false); // не знаю, зачем это вообще нужно :)
user_pref("browser.turbo.enabled", false); // у кого включено - отключаем. параметр загружает часть Фокса в память для быстрого запуска. у нас теперь и так всё быстро и в памяти
user_pref("config.trim_on_minimize", false); // тоже не надо. параметр скидывает Фокс из памяти в своп. на висте и 7 всеравно не работает
// Обновления
user_pref("app.update.auto", true); //
user_pref("app.update.enabled", false); // эти параметры
user_pref("app.update.mode", 1); // отключают обновление браузера,
user_pref("app.update.silent", true); // и включают
user_pref("browser.search.update", true); // незаметное обновление
user_pref("extensions.update.enabled", true); // плагинов
user_pref("extensions.update.notifyUser", false); //`
Что ещё? Кто знает, какие параметры ещё можно изменить, пишите в комментариях.
#### Скрипты
Теперь беремся за nnCron. В кроне ничего сложного делать не придётся. Надо всего-лишь скопировать плагин [ini.spf](http://www.nncron.ru/download/plugins/ini.spf) в папку с плагинами C:\Program Files\nnCron\plugins, и подключить его через меню в трее: Параметры > Плагины > Добавить.
Ну и самое главное — установить скрипты.
#### Запуск
Запускаем первый скрипт — Loading\_Firefox\_into\_RamDisk. На рамдиске будет создана рабочая копия Фокса, оттуда можно наделать ярлыков на рабочий стол и в панель быстрого запуска.
Этот скрипт будет также загружать Firefox на рамдиск при входе в систему. Вначале загрузится всё, кроме кэша и исполняемого файла firefox.exe. Я сделал так для того, чтобы не запустить Фокс, пока все файлы до конца не скопировались.
Затем скопируется firefox.exe, после чего можно запустить браузер, кэш будет дозагружаться уже параллельно сёрфингу.
`#( Loading_Firefox_into_RamDisk
AsLoggedUser
SingleInstance
WatchLogon: "*"
Action:
SWHide
StartIn: "C:\Program Files\nnBackup\"
START-APPW: nnbackup.exe sync -i D:\BackUp\Firefox -o R:\Firefox -s -c -x firefox.exe -dx Cache
FILE-WRITE: "%AppData%\Mozilla\Firefox\profiles.ini" "[General]%crlf%StartWithLastProfile=1%crlf%%crlf%[Profile0]%crlf%Name=Default User%crlf%IsRelative=0%crlf%Path=R:\Firefox\Profile%crlf%Default=1"
S" R:\Firefox\Profile\compatibility.ini" INI-FILENAME
S" Compatibility" INI-SECTION
S" LastPlatformDir" S" R:\Firefox\App" INI-SET-VALUE
S" LastAppDir" S" R:\Firefox\App" INI-SET-VALUE
START-APP: nnbackup.exe sync -i D:\BackUp\Firefox\App -o R:\Firefox\App -c -m firefox.exe
START-APP: nnbackup.exe sync -i D:\BackUp\Firefox\Profile\Cache -o R:\Firefox\Profile\Cache -c
)#`
#### Бэкап
Бэкап у нас инкрементальный, поэтому очень быстрый :) С рамдиска Фокс будет бэкапиться при закрытии и каждый час. Тут всё элементарно: бэкапим профиль без кэша, затем кэш (профиль ценнее! :))
`#( BackUp_Firefox
AsLoggedUser
SingleInstance
WatchProcStop: "firefox.exe"
Rule: PROC-EXIST: "firefox.exe" NOT
Action:
SWHide IdlePriority
AsService
StartIn: "C:\Program Files\nnBackup\"
FILE-WRITE: "%AppData%\Mozilla\Firefox\profiles.ini" "[General]%crlf%StartWithLastProfile=1%crlf%%crlf%[Profile0]%crlf%Name=Default User%crlf%IsRelative=0%crlf%Path=R:\Firefox\Profile%crlf%Default=1"
S" R:\Firefox\Profile\compatibility.ini" INI-FILENAME
S" Compatibility" INI-SECTION
S" LastPlatformDir" S" R:\Firefox\App" INI-SET-VALUE
S" LastAppDir" S" R:\Firefox\App" INI-SET-VALUE
START-APPW: nnbackup.exe sync -i R:\Firefox -o D:\BackUp\Firefox -s -ad -c -dx Cache
START-APP: nnbackup.exe sync -i R:\Firefox\Profile\Cache -o D:\BackUp\Firefox\Profile\Cache -ad -da -c
)#
#( BackUp_Firefox_One_Hour
AsLoggedUser
SingleInstance
Time: 0 * * * * *
Action: BackUp_Firefox RUN
)#`
#### Обновление
Обновляться Firefox будет два раза в неделю, а файлы для обновления скрипт будет добывать из ночных сборок.
Можно использовать такие папки:
*latest-electrolysis/
latest-firefox-3.0.x-l10n/
latest-firefox-3.0.x/
latest-firefox-3.5.x-l10n/
latest-firefox-3.5.x/
latest-mozilla-1.9.1-l10n/
latest-mozilla-1.9.1/
latest-mozilla-1.9.2-l10n/
latest-mozilla-1.9.2/
latest-mozilla-central-l10n/
latest-mozilla-central/
latest-mozilla1.9.0-l10n/
latest-mozilla1.9.0/
latest-places/
latest-tracemonkey/
latest-trunk/*
Скрипт должен подхватить ссылку из любой из этих папок.
Перед скриптом задаётся локальная переменная *foxlink*, в ней вы укажете полный путь к одной из вышеперечисленных папок.
Вот [здесь](http://ftp.mozilla.org/pub/mozilla.org/firefox/nightly/) щёлкаете правой кнопкой на нужной сборке, копируете линк, и вставляете его в переменную foxlink. Целиком, вместе со слэшем "/" в конце (наверное, так будет чуточку удобнее и вам и мне).
Кому нужна русская версия Фокса, берите линк папки, имя которой заканчивается на -l10n.
Впрочем, ниже на примере итак всё видно.
Ещё одна переменная -*dspeed*. Это ограничитель скорости загрузки, в килоБАЙТах. Сделано для того чтобы автоапдейт не мешал сёрфить/работать :)
`SET foxlink=http://ftp.mozilla.org/pub/mozilla.org/firefox/nightly/latest-mozilla-1.9.1-l10n/
SET dspeed=256k
#( Update_Firefox
AsLoggedUser
SingleInstance
Time: 0 20 * * 3,7 *
Action:
SWHide IdlePriority
AsService
StartIn: "C:\Program Files\Wget\"
DIR-DELETE: "R:\Updates\Firefox"
START-APPW: wget.exe %foxlink% -P R:\Updates\Firefox\ -c --limit-rate=%dspeed% --wait=2m --tries=60
FILE-EXIST: "R:\Updates\Firefox\index.html" NOT
IF
LOG: "D:\BackUp\update.log" ">> Ошибка. Страница загрузки Firefox не найдена [%FT-CUR FT>DD.MM.YYYY/hh:mm:ss%]"
EXIT
THEN
RE-MATCH: "%FILE: R:\Updates\Firefox\index.html%" "/firefox-\d\.\d(\.\d(\d)*)*(\l\d)*pre\.(en-US)|(ru)\.win32\.zip/i"
IF
START-APPW: wget.exe %foxlink%%$0% -P R:\Updates\Firefox\ -c --limit-rate=%dspeed% --wait=2m --tries=60
FILE-EXIST: "R:\Updates\Firefox\%$0%" NOT
IF
DIR-DELETE: "R:\Updates\Firefox"
LOG: "D:\BackUp\update.log" ">> Ошибка загрузки %$0% [%FT-CUR FT>DD.MM.YYYY/hh:mm:ss%]"
EXIT
THEN
START-APPW: WinRAR.exe t R:\Updates\Firefox\%$0% -r -y
ExitCodeProc 0 <>
IF
LOG: "D:\BackUp\update.log" ">> Ошибка в архиве %$0% [%FT-CUR FT>DD.MM.YYYY/hh:mm:ss%]"
EXIT
THEN
START-APPW: WinRAR.exe x R:\Updates\Firefox\%$0% R:\Updates\Firefox\ -y
ExitCodeProc 0 <>
IF
LOG: "D:\BackUp\update.log" ">> Ошибка распаковки %$0% [%FT-CUR FT>DD.MM.YYYY/hh:mm:ss%]"
EXIT
THEN
PAUSE: 10000
START-APPW: nnbackup.exe sync -i R:\Updates\Firefox\firefox -o D:\BackUp\Firefox\App -s -ad -c
BEGIN PAUSE: 250 PROC-EXIST: "firefox.exe" NOT UNTIL
FILE-DELETE: "R:\Firefox\App\firefox.exe"
START-APPW: nnbackup.exe sync -i R:\Updates\Firefox\firefox -o R:\Firefox\App -s -ad -c -x firefox.exe
START-APPW: nnbackup.exe -i R:\Updates\Firefox\firefox\firefox.exe -o R:\Firefox\App -c
LOG: "D:\BackUp\update.log" "Успешное обновление %$0% [%FT-CUR FT>DD.MM.YYYY/hh:mm:ss%]"
DIR-DELETE: "R:\Updates\Firefox"
ELSE
DIR-DELETE: "R:\Updates\Firefox"
LOG: "D:\BackUp\update.log" ">> Ошибка. Ссылка на Firefox не найдена [%FT-CUR FT>DD.MM.YYYY/hh:mm:ss%]"
THEN
)#`
Принцип обновления таков: парсится страница на предмет нужной ссылки, скачивается архив, проверяется-распаковывается, обновляются файлы в бэкапе.
Если Firefox запущен, то скрипт ждёт, пока Фокс не закроется, и затем уже обновляет файлы на рамдиске.
Hint: Немного понажимав кнопочки, можно с легкостью переделать этот скрипт для обновления Thunderbird.
Вцелом, всё работает достаточно стабильно, однако если будут возникать сложности со скриптами — пишите в комментариях, я постараюсь их исправить.
**UPD:** товарищ попросил разместить ссылку на вариант под линукс: [Разгон Firefox при помощи TmpFS](http://dals.habrahabr.ru/blog/48367/) | https://habr.com/ru/post/72463/ | null | ru | null |
# Тестирование в Openshift: Интеграция с Openstack
Здравствуйте, уважаемые участники ИТ сообщества. Данный материал является незапланированным продолжением серии статей ([первая статья](https://habrahabr.ru/post/332994/), [вторая статья](https://habrahabr.ru/post/333012/), [третья статья](https://habrahabr.ru/post/333014/)), которые посвящены тестированию ПО в [Openshift Origin](https://habrahabr.ru/post/333014/). В данной статье будут рассмотрены аспекты интеграции контейнеров и виртуальных машин посредством Openshift и [Openstack](http://openstack.org/).
Какие цели я преследовал интегрируя Openshift с Openstack:
1. Добавить возможность запускать контейнеры и виртуальные машины в единой сети ([L2](https://en.wikipedia.org/wiki/OSI_model), отсутствие вложенных сетей).
2. Добавить возможность использования опубликованных в Openshift сервисов виртуальными машинами.
3. Добавить возможность интеграции физического сегмента сети с сетью контейнеров/виртуальных машин.
4. Иметь возможность обоюдного разрешения [FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) для контейнеров и виртуальных машин.
5. Иметь возможность встроить процесс развертывания гибридных окружений (контейнеры, виртуальные машины) в существующий [CI](https://en.wikipedia.org/wiki/Continuous_integration)/[CD](https://en.wikipedia.org/wiki/Continuous_delivery#Relationship_to_continuous_deployment).
*Примечание: в данной статье не пойдет речи об автоматическом масштабировании кластера и предоставлении хранилищ данных.*
Своими словами о программном обеспечении, которое способствовало достижению поставленных целей:
1. Openstack — операционная система для создания облачных сервисов. Мощный конструктор, который собрал под своё начало множество проектов и вендоров. По моему личному мнению конкурентов Openstack на рынке [private cloud](https://en.wikipedia.org/wiki/Cloud_computing#Private_cloud) просто нет. Инсталяции Openstack могут быть очень гибкими и многоэлементными, с поддержкой различных гипервизоров и сервисов. Доступны плагины Jenkins[[1]](https://wiki.jenkins.io/display/JENKINS/Openstack+Cloud+Plugin)[[2]](https://wiki.jenkins.io/display/JENKINS/Openstack+Heat+Plugin). Поддерживается [оркестрация](https://wiki.openstack.org/wiki/Heat), [workflow](https://wiki.openstack.org/wiki/Mistral), [multi tenancy](https://wiki.openstack.org/wiki/HierarchicalMultitenancy), [zoning](https://www.mirantis.com/blog/the-first-and-final-word-on-openstack-availability-zones/) и т.д.
2. Openshift Origin — standalone решение от Red Hat (в противовес [Openshift Online и Openshift Dedicated](https://en.wikipedia.org/wiki/OpenShift)) предназаченное для оркестрации контейнеров. Решение построено на базе [Kubernetes](https://en.wikipedia.org/wiki/Kubernetes), но обладает рядом преимуществ/дополнений, которые обеспечивают удобство и эффективность работы.
3. [Kuryr](https://wiki.openstack.org/wiki/Kuryr) — молодой проект Openstack (большой плюс в том, что разработка ведется в экосистеме Openstack), позволяет различными способами интегрировать контейнеры (nested, baremetal) в сеть [Neutron](https://wiki.openstack.org/wiki/Neutron). Является простым и надежным решением c далеко идущими планами по расширению функционала. На текущий момент на рынке представлено множество решений [NFV](https://en.wikipedia.org/wiki/Network_function_virtualization)/[SDN](https://en.wikipedia.org/wiki/Software-defined_networking) (коим Kuryr не является), большая часть из которых может быть исключена как не поддерживаемая Openstack/Openshift нативно, но даже существенно сократив список остаются решения, которые весьма богаты функционально, нр при этом являются достаточно сложными с точки зрения интеграции и сопровождения ([OpenContrail](http://www.opencontrail.org/), [MidoNet](https://www.midonet.org/), [Calico](https://www.projectcalico.org/), [Contiv](https://contiv.github.io/), [Weave](https://www.weave.works/)). Kuryr же позволяет без особых трудностей интегрировать контейнеры Openshift ([CNI](https://github.com/containernetworking/cni) плагин) в сеть Neutron (классический сценарии с [OVS](http://openvswitch.org/)).
#### Типовые схемы интеграции:
**1. Кластер Openshift размещен в облаке Openstack**
Схема интеграции, когда все элементы расположены в облаке Openstack, весьма привлекательна и удобна, но главный минус данной схемы заключается в том, что контейнеры запускаются в виртуальных машинах и все преимущества в скорости сводятся на нет.
При данной схеме интеграции рабочим узлам Openshift назначается [TRUNK](https://wiki.openstack.org/wiki/Neutron/TrunkPort) порт, который содержит некоторое количество SUBPORT. Каждый SUBPORT содержит индетификатор [VLAN](https://en.wikipedia.org/wiki/Virtual_LAN). Если TRUNK порт находится в одной сети, то SUBPORT находится в другой. SUBPORT стоит рассматривать как мост между двумя сетями. При поступлении Ethernet кадра в TRUNK c меткой VLAN (которая соотвествует некому SUBPORT), то такой кадр будет направлен в соотвествующий SUBPORT. Из всего этого следует, что на рабочем узле Openshift создается обычный VLAN, который помещается в [network namespace](https://en.wikipedia.org/wiki/Linux_namespaces) контейнера.
**2. Рабочие ноды Openshift кластера являются физическими серверами, master размещен в облаке Openstack**
Схема интеграции, когда контейнеры запущены на выделенных серверах, не сложнее схемы со всеми элементами расположенными в облаке Openstack. [VXLAN](https://en.wikipedia.org/wiki/Virtual_Extensible_LAN) позволяет организовать виртуальные сети без необходимости сегментирования сети предприятия.
При данной схеме интеграции на рабочих узлах Openshift работает [Open vSwitch Agent](https://docs.openstack.org/liberty/networking-guide/scenario-classic-ovs.html), который интегрирован c Neutron. Запущенному контейнеру назначается [VETH](https://lwn.net/Articles/232688/) устройство, которое работает напрямую с мостом Open vSwitch, то есть контейнер интегрируется в сеть Neutron напрямую. В последующем Open vSwitch Agent инициирует VXLAN соединение с Neutron Router для последущей маршрутизации пакетов.
**Роль Kuryr во всех вариантах сводится к:**
1. При создании контейнера будет задействован kuryr CNI плагин, который отправит запрос (все коммуникации осуществляются через стандартный API Openshift/Kubernetes) kuryr-controller на подключение к сети.
2. kuryr-controller получив запрос "попросит" Neutron выделить порт. После инициализации порта, kuryr-controller передаст сетевую конфигурацию обратно CNI плагину, которая и будет применена к контейнеру.
#### Интеграция физического сегмента сети c сетью контейнеров и виртуальных машин:
В самом простом варианте участники разработки имеют машрутизируемый доступ в сеть контейнеров и виртуальных мышин посредством Neutron Router, для этого достаточно прописать на рабочих станциях адрес шлюза для нужной подсети. Данную возможность трудно переоценить с точки зрения тестирования, так как стандартные механизмы ([hostNetwork, hostPort, NodePort, LoadBalancer, Ingress](http://alesnosek.com/blog/2017/02/14/accessing-kubernetes-pods-from-outside-of-the-cluster/)) Openshift/Kubernetes явно ограничены в возможностях, равно как и [LBaaS](https://wiki.openstack.org/wiki/Neutron/LBaaS) в Openstack.
Особенно трудно переоценить возможность разворачивать и иметь доступ к нужным приложениям, каталог которых доступен через веб-интерфейс Openshift (если такие проекты как [Monocular](https://github.com/kubernetes-helm/monocular) начали появляться сравнительно недавно, то в Openshift данный функционал присутствует с первых версий). Любой участник разработки может развернуть доступное приложение не тратя времени на изучение [Docker](http://docker.io/), Kubernetes, самого приложения.
#### Разрешение FQDN контейнеров и виртуальных машин:
В случае с контейнерами всё очень просто, для каждого опубликованного сервиса создается FQDN запись во внутреннем DNS сервере по следующей схеме:
`..svc.cluster.local`
В случае с виртуальными машинами используется расширение [dns](https://docs.openstack.org/mitaka/networking-guide/config-dns-int.html) для [ml2](https://wiki.openstack.org/wiki/Neutron/ML2) плагина:
`extension_drivers = port_security,dns`
При создании порта в Neutron задается аттрибут dns\_name, которой и формирует FQDN:
```
[root@openstack ~]# openstack port create --dns-name hello --network openshift-pod hello
+-----------------------+---------------------------------------------------------------------------+
| Field | Value |
+-----------------------+---------------------------------------------------------------------------+
| admin_state_up | UP |
| allowed_address_pairs | |
| binding_host_id | |
| binding_profile | |
| binding_vif_details | |
| binding_vif_type | unbound |
| binding_vnic_type | normal |
| created_at | 2017-10-04T15:25:21Z |
| description | |
| device_id | |
| device_owner | |
| dns_assignment | fqdn='hello.openstack.local.', hostname='hello', ip_address='10.42.0.15' |
| dns_name | hello |
| extra_dhcp_opts | |
| fixed_ips | ip_address='10.42.0.15', subnet_id='4e82d6fb-9613-4606-a3ae-79ed8de42eea' |
| id | adfa0aab-82c6-4d1e-bec3-5d2338a48205 |
| ip_address | None |
| mac_address | fa:16:3e:8a:94:38 |
| name | hello |
| network_id | 050a8277-e4b3-4927-9762-d74274d9c8ff |
| option_name | None |
| option_value | None |
| port_security_enabled | True |
| project_id | 2823b3394572439c804d56186cc82abb |
| qos_policy_id | None |
| revision_number | 6 |
| security_groups | 3d354277-2aec-4bfb-91ac-d320bfb6c90f |
| status | DOWN |
| subnet_id | None |
| updated_at | 2017-10-04T15:25:21Z |
+-----------------------+---------------------------------------------------------------------------+
```
FQDN для виртуальной машины может быть разрешен с помощью DNS сервера, который обслуживает [DHCP](https://en.wikipedia.org/wiki/Dynamic_Host_Configuration_Protocol) для данной сети.
Остается лишь разместить на Openshift master (или в любом другом месте) DNS resolver, который будет разрешать `*.cluster.local` с помощью [SkyDNS Openshift](https://docs.openshift.org/latest/architecture/networking/networking.html), а `*.openstack.local` с помощью DNS сервера сети Neutron.
#### Демонстрация:
#### Заключение:
1. Хочется выразить благодарность командам разработчиков: Openshift/Kubernetes, Openstack, Kuryr.
2. Решение получилось максимально простым, но при этом осталось гибким и функциональным.
3. Благодаря Openstack открылась возможность организовать тестирование на таких процессорных архитектурах как ARM и MIPS.
#### Интересное:
1. [Openshift и Windows Containers](https://www.youtube.com/watch?v=B0qqnnmcb9w)
2. [CRI-O поддерживает Clear Containers](http://cri-o.io/) | https://habr.com/ru/post/339474/ | null | ru | null |
# Массовая уязвимость в проектах на Ruby
Опубликовано [сообщение](http://homakov.blogspot.com/2012/05/saferweb-injects-in-various-ruby.html#more) о массовой уязвимости в проектах на Ruby. Речь идёт об использовании `^` в начале строки и `$` в конце строки регулярных выражений вместо `\A` и `\z`.
Дело в том, что `^` и `$` в таких случаях воспринимается Ruby как новые строки (`\n`), что открывает двери для инъекций.
Хотя официальное руководство по безопасности Ruby on Rails [предупреждает](http://guides.rubyonrails.org/security.html#regular-expressions) об этой опасности, но всё равно подобная небрежность встречается в 90% проектов на Ruby, в доказательство чего приводятся примеры на Github, Scribd, Tumblr и других сервисах.
Как и в [прошлый раз c Rails](http://habrahabr.ru/post/139399/), здесь можно спорить, баг это или «ожидаемое поведение» системы. Но если большинство разработчиков делают ошибку из-за такой «особенности», так почему бы не исправить правила обработки строк в Ruby? | https://habr.com/ru/post/144139/ | null | ru | null |
# Две сети по одному кабелю между Mikrotik Router OS и Shibby Tomato USB на Netgear WNR3500L
#### Предпосылки
Изначально имелся маршрутизатор Mikrotik, он же – точка доступа. На проводную и беспроводную сети была выделена разная адресация. Это удобно, если с ноутбука, подключенного по беспроводной сети, требуется получать высокоскоростной доступ к локальным ресурсам (сетевому хранилищу) по гигабитному проводу.
Но, вот беда, сеть использовалась с двух этажей, а проводной доступ был только на одном. Да и качество беспроводной связи на этаже без точки оставляло желать лучшего. К тому же, был в наличии неиспользуемый Netgear WNR3500L.
#### Ничто не предвещало беды
Официально TomatoUSB от Shibby поддерживает тэгированные вланы и даже, в экспериментальном порядке, позволяет переназначать VID'ы (доступно всего 15 вланов, и без переназначения их VID'ы, соответственно, от 1 до 15). Решение, казалось бы, лежит на поверхности.
##### На Микротике
Создаём два влана на порту подключения Нетгира, один влан объединяем в мост с беспроводным интерфейсом, другой – с мастер-интерфейсом езернет-коммутатора. Как это сделать, я описывать не буду, потому как на Mikrotik Router OS существует [подробная всеобъемлющая документация](http://wiki.mikrotik.com/wiki/Main_Page). Адресацию, DHCP-сервера, IGMP (для работы DLNA между сетями) и прочие настройки перевешиваем на вновь созданные мосты.
##### На Нетгире
Теоретически, нам нужно принять два влана через WAN и раздать без тэгов на LAN-коммутатор и беспроводной интерфейс, соответственно. Но если с проводной сетью всё просто, то что делать с беспроводной?
**Advanced → VLAN** Нам бы подключить её в мост с соответствующим вланом, так же, как на Микротике. Но веб-интерфейс помидора этого сделать не позволяет. Так же, как и не позволяет включить WiFi-интерфейс во влан (забегая вперёд, скажу, что такая возможность не предусмотрена на железном уровне, если я достаточно разобрался в коде). Тупик.
#### Погружение
Проблема используемой прошивки заключается в том, что при наличии минимальной справки по веб-интерфейсу внутренности документированы чуть менее, чем никак. Только изучение исходников прошивки позволило мне получить знания, которые привели меня к решению задачи. Ими я с вами и поделюсь.
##### Прежде, чем ставить эксперименты
Небольшая предварительная настройка сэкономит вам кучу времени и нервов.
*Рис. 1*: включаем ответ на ICMP-запросы.
**Advanced → Firewall***Рис. 2*: включаем сервер SSH, выключаем телнет и вписываем свой открытый ключ.
**Administration → Admin Access***Рис. 3*: на случай, если что-то пойдёт не так, подготовим скрипт, возвращающий сетевые настройки в исходное состояние, и повесим его исполнение на кнопку WPS. В противном случае, при каждом неудачном действии с сетью мы будем вынуждены сбросить маршрутизатор в конфигурацию по умолчанию и загрузить резервную копию конфигурации (да, вы ведь сделали бэкап, прежде чем пускаться во все тяжкие?). Процедура отнимает минут пять и при регулярном выполнении изрядно нервирует.
**Administration → Button/LED****Custom Script**
```
nvram set lan1_ifname=
nvram set lan1_ifnames=
nvram set lan1_ipaddr=
nvram set lan1_netmask=
nvram set lan1_proto=
nvram set lan1_stp=
nvram set lan_desc=1
nvram set lan_dhcp=0
nvram set lan_domain=
nvram set lan_gateway=
nvram set lan\_hostname=
nvram set lan\_hwaddr=
nvram set lan\_hwnames=
nvram set lan\_ifname=br0
nvram set lan\_ifnames=vlan1
nvram set lan\_invert=0
nvram set lan\_ipaddr=
nvram set lan\_lease=86400
nvram set lan\_netmask=
nvram set lan\_proto=static
nvram set lan\_route=
nvram set lan\_state=1
nvram set lan\_stp=0
nvram set lan\_wins=
nvram set landevs=vlan1
nvram set vlan1hwname=et0
nvram set vlan1ports=1 2 3 4 8\*
nvram set vlan1vid=
nvram set vlan2hwname=et0
nvram set vlan2ports=0 8
nvram set vlan2vid=
nvram set vlan3hwname=
nvram set vlan3ports=
nvram set vlan3vid=
nvram set vlan4hwname=
nvram set vlan4ports=
nvram set vlan4vid=
nvram commit
reboot
```
Текущие значения для внесения в скрипт можно получить командой **nvram show**. Если у вас не гигабитный, а стомегабитный маршрутизатор, восьмёрку в параметрах **vlan*X*ports** меняем на пятёрку.
##### И собственно настройка
*Рис. 4*: для того, чтобы WAN оказался в состоянии UP, прошивка обязывает нас настроить на нём что угодно поверх езернета: хоть IP, хоть туннель. Значение *disable* сделает порт полностью неактивным, а объединение его с LAN-коммутатором – это не то, чего мы хотим. Можно было бы повесить на него любой ip-адрес, но возникает вероятность затыка маршрутизации в будущем. Адрес 0.0.0.0 также выключит порт. Оптимальное решение – присвоить интерфейсу link-local адрес.
*Рис. 5*: в нашем случае бесполезно указывать в этом поле шлюз по умолчанию. (Доступ в интернет может понадобиться маршрутизатору по нескольким причинам. Во-первых, это синхронизация времени. Также, у меня используется сборка Tomato с торрент-клиентом).
*Рис. 6*: хоть веб-интерфейс и не позволяет объединить в мост влан и беспроводную сеть, сама прошивка это сделать может. Поэтому сконфигурируем второй мост. Мостам присвоены адреса из блоков, выделенных ранее на Микротике для проводной и беспроводной сетей, соответственно.
*Рис. 7*: а вот указанные на этой вкладке DNS-сервера, в противовес шлюзу по умолчанию, работать будут.**Basic → Network***Рис. 8*: маршрут по умолчанию укажем вручную как статический.**Advanced → Routing***Рис. 9*: пропускаем оба влана с тэгами на порт WAN.
*Рис. 10*: добавляем беспроводной интерфейс в созданный ранее второй мост. Пока беспроводная сеть будет единственной составляющей моста.
*Рис. 11*: а вот тут внимание! Практика показала, что на используемом маршрутизаторе этот функционал не работает, поэтому придётся использовать те VID'ы, которые доступны на Нетгире: с первого по пятнадцатый.**Advanced → VLAN**##### А теперь обещанная расчленёнка
Из консольных утилит нам интересны, в первую очередь, **nvram** и **robocfg**. Первая позволяет взаимодействовать с областью flash-памяти, в которой хранится конфигурация прошивки в виде массива пар *переменная=значение*. Вторая – управлять конфигурацией вланов на портах. Впрочем, для описываемой ситуации дальнейшая работа с вланами не потребуется. Также нам доступны стандартные **ifconfig**, **vconfig**, **brctl** и **ip**.
Изучив список интерфейсов, мы увидим, что в наличии имеются два моста (сами настраивали), два езернет-интерфейса (*eth0* – проводная сеть, *eth1* – беспроводная) и два влана. Отдельного езернет-интерфейса порт WAN не удостоился. С помощью какого-то сильного колдунства от его имени выступает влан, назначенный виртуальному мосту WAN на странице *Advanced → VLAN* веб-интерфейса.
Чтобы взглянуть на конфигурацию, выполним команду
```
nvram show
```
Интерес представляют параметры, начинающиеся с **wan\_** и *lan*. Первая группа параметров описывает, как несложно догадаться, WAN-интерфейс, а вторая является ничем иным, как списком мостов. Всего их в системе может быть до четырёх, один из которых обязателен (группа параметров **lan\_**).
Именно **wan\_ifnameX** указывает на тот влан, который станет WAN'ом. А **lan*X*\_ifnames** – содержит список интерфейсов, включённых в мост. Зная это, мы можем сделать то, что не даёт выполнить веб-интерфейс – объединить в мост влан и беспроводную сеть.
```
nvram set lan1_ifnames=vlan2 eth1
nvram commit
reboot
```
Профит.
Осталось настроить беспроводную сеть с ключом и именем аналогичными сети на первой точке.
##### Напоследок
Набор параметров **vlan*X*\_** описывает 15 вланов, которые мы можем настроить на маршрутизаторе. Параметр **hwname** – имя драйвера интерфейса; **ports** – порты, на которые выходит влан: 0 – WAN, 1-4 – порты коммутатора, 8 (для 100Мб – 5) – виртуальный порт процессора, должен присутствовать в каждом влане. Буква *t* после номера порта означает, что на данном порту влан будет тэгироваться. Звёздочка – «влан по умолчанию», этим вланом внутри коммутатора тэгируются пакеты, пришедшие без тэга. Параметр **vid** задаёт альтернативный VID для влана. Но этот функционал, как сказано выше, не работает.
Упоминания параметра **ports** я в коде, за исключением исходников утилиты **robocfg**, не нашёл. Видимо, он используется драйвером, который поставляется в бинарном виде. | https://habr.com/ru/post/181780/ | null | ru | null |
# Машинное обучение руками «не программиста»: классификация клиентских заявок в тех.поддержку (часть 1)
Привет! Меня зовут Кирилл и я ~~алкоголик~~ более 10 лет был менеджером в сфере ИТ. Я не всегда был таким: во время учебы в МФТИ писал код, иногда за вознаграждение. Но столкнувшись с суровой реальностью (в которой необходимо зарабатывать деньги, желательно побольше) пошел по наклонной — в менеджеры.
Но не все так плохо! С недавнего времени мы с партнерами целиком и полностью ушли в развитие своего стартапа: системы учета клиентов и клиентских заявок [Okdesk](https://www.okdesk.ru). С одной стороны — больше свободы в выборе направления движения. Но с другой — нельзя просто так взять и заложить в бюджет "3-х разработчиков на 6 месяцев для проведение исследований и разработки прототипа для…". Много приходится делать самим. В том числе — непрофильные эксперименты, связанные с разработкой (т.е. те эксперименты, что не относятся к основной функциональности продукта).
Одним из таких экспериментов стала разработка алгоритма классификации клиентских заявок по текстам для дальнейшей маршрутизации на группу исполнителей. В этой статье я хочу рассказать, как "не программист" может за 1,5 месяца в фоновом режиме освоить python и написать незамысловатый ML-алгоритм, имеющий прикладную пользу.
Как учиться?
============
В моём случае — дистанционное обучение на Coursera. Там довольно много курсов по машинному обучению и другим дисциплинам, связанным с искусственным интеллектом. Классикой считается [курс](https://www.coursera.org/learn/machine-learning) основателя Coursera Эндрю Ына (Andrew Ng). Но минус этого курса (помимо того, что курс на английском языке: это не всем по силам) — редкостный инструментарий Octave (бесплатный аналог MATLAB-а). Для понимания алгоритмов это не главное, но лучше учиться на более популярных инструментах.
Я выбрал специализацию "[Машинное обучение и анализ данных](https://www.coursera.org/specializations/machine-learning-data-analysis)" от МФТИ и Яндекса (в ней 6 курсов; для того что написано в статье, достаточно первых 2-х). Главное преимущество специализации — это живое сообщество студентов и менторов в Slack-е, где почти в любое время суток есть кто-то, к кому можно обратиться с вопросом.
Что такое "Машинное обучение"?
==============================
В рамках статьи не будем погружаться в терминологические споры, поэтому желающих придраться к недостаточной математической точности прошу воздержаться (обещаю, что не буду выходить за рамки приличия :).
Итак, что же такое машинное обучение? Это набор методов для решения задач, требующих каких-либо интеллектуальных затрат человека, но при помощи вычислительных машин. Характерной чертой методов машинного обучения является то, что они "обучаются" на прецедентах (т.е. на примерах с заранее известными правильными ответами).
Более математизированное определение выглядит так:
1. Имеется множество объектов с набором характеристик. Обозначим это множество буквой ***X***;
2. Есть множество ответов. Обозначим это множество буквой ***Y***;
3. Существует (неизвестная) зависимость между множеством объектов и множеством ответов. Т.е. такая функция, которая ставит в соответствие объекту множества ***X*** объект множества ***Y***. Назовем её функцией ***y***;
4. Имеется конечное подмножество объектов из ***X*** (обучающая выборка), для которой известны ответы из ***Y***;
5. По обучающей выборке необходимо максимально хорошо приблизить функцию ***y*** какой-то функцией ***a***. При помощи функции ***a*** мы хотим для любого объекта из ***X*** получить с хорошей вероятностью (или точностью — если речь о числовых ответах) верный ответ из ***Y***. Поиск функции ***a*** — задача машинного обучения.
Вот пример из жизни. Банк выдает кредиты. У банка накопилось множество анкет заёмщиков, для которых уже известен исход: вернули кредит, не вернули, вернули с просрочкой и т.д. Объектом в этом примере является заемщик с заполненной анкетой. Данные из анкеты — параметры объекта. Факт возврата или невозврата кредита — это "ответ" на объекте (анкете заёмщика). Совокупность анкет с известными исходами является обучающей выборкой.
Возникает естественное желание уметь предсказывать возврат или невозврат кредита потенциальным заемщиком по его анкете. Поиск алгоритма предсказания — задача машинного обучения.
Примеров задач машинного обучения множество. В этой статье подробнее поговорим о задаче классификации текстов.
Постановка задачи
=================
Напомним о том, что мы разрабатываем [Okdesk](https://www.okdesk.ru) — облачный сервис для обслуживания клиентов. Компании, которые используют Okdesk в своей работе, принимают клиентские заявки по разным каналам: клиентский портал, электронная почта, web-формы с сайта, мессенджеры и так далее. Заявка может относиться к той или иной категории. В зависимости от категории у заявки может быть тот или иной исполнитель. Например, заявки по 1С должны отправляться на решение к специалистам 1С, а заявки связанные с работой офисной сети — группе системных администраторов.
Для классификации потока заявок можно выделить диспетчера. Но, во-первых, это стоит денег (зарплата, налоги, аренда офиса). А во-вторых, на классификацию и маршрутизацию заявки будет потрачено время и заявка будет решена позже. Если бы можно было классифицировать заявку по её содержанию автоматически — было бы здорово! Попробуем решить эту задачу силами машинного обучения (и одного ИТ-менеджера).
Для проведения эксперимента была взята выборка из 1200 заявок с проставленными категориями. В выборке заявки распределены по 14-ти категориям. Цель эксперимента: разработать механизм автоматической классификации заявок по их содержанию, который даст в разы лучшее качество, по сравнению с random-ом. По результатам эксперимента необходимо принять решение о развитии алгоритма и разработке на его базе промышленного сервиса для классификации заявок.
Инструментарий
==============
Для проведение эксперимента использовался ноутбук Lenovo (core i7, 8гб RAM), язык программирования Python 2.7 с библиотеками NumPy, Pandas, Scikit-learn, re и оболочкой [IPython](https://ru.wikipedia.org/wiki/IPython). Подробнее напишу об используемых библиотеках:
1. **NumPy** — библиотека, содержащая множество полезных методов и классов для проведения арифметических операций с большими многомерными числовыми массивами;
2. **Pandas** — библиотека, позволяющая легко и непринужденно анализировать и визуализировать данные и проводить операции над ними. Основные структуры данных (типы объектов) — [Series](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html) (одномерная структура) и [DataFrame](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html) (двумерная структура; по сути — набор Series одинаковой длины).
3. **Scikit-learn** — библиотека, в которой реализовано большинство методов машинного обучения;
4. **Re** — библиотека регулярных выражений. [Регулярные выражения](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%80%D0%BD%D1%8B%D0%B5_%D0%B2%D1%8B%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F) — незаменимый инструмент в задачах, связанных с анализом текстов.
Из библиотеки Scikit-learn нам понадобятся некоторые модули, о предназначение которых я напишу по ходу изложения материала. Итак, импортируем все необходимые библиотеки и модули:
```
import pandas as pd
import numpy as np
import re
from sklearn import neighbors, model_selection, ensemble
from sklearn.grid_search import GridSearchCV
from sklearn.metrics import accuracy_score
```
И переходим к подготовке данных.
*(конструкция import xxx as yy означает, что мы подключаем библиотеку xxx, но в коде будем обращаться к ней через yy)*
Подготовка данных
=================
При решении первых реальных (а не лабораторных) задач, связанных с машинным обучением, вы откроете для себя, что основная часть времени уходит не на обучение алгоритма (выбор алгоритма, подбор параметров, сравнение качества разных алгоритмов и т.д.). Львиная доля ресурсов уйдет на сбор, анализ и подготовку данных.
Есть различные приемы, методы и рекомендации по подготовке данных для разных классов задач машинного обучения. Но большинство экспертов называют подготовку данных скорее искусством, чем наукой. Есть даже такое выражение — feature engineering (т.е. конструирование параметров, описывающих объекты).
В задаче классификации текстов "фича" у объекта одна — текст. Скормить его алгоритму машинного обучения нельзя (допускаю, что мне не все известно :). Текст необходимо как-то оцифровать и формализовать.
В рамках эксперимента использовались примитивные методы формализации текстов (но даже они показали неплохой результат). Об этом поговорим далее.
Загрузка данных
---------------
Напомним, что в качестве исходных данных у нас есть выгрузка 1200 заявок (распределенных неравномерно по 14 категориям). Для каждой заявки есть поле "Тема", поле "Описание" и поле "Категория". Поле "Тема" — сокращенное содержание заявки и оно обязательно, поле "Описание" — расширенное описание и оно может быть пустым.
Данные загружаем из .xlsx файла в DataFrame. В .xlsx файле много столбцов (параметров реальных заявок), но нам нужны только "Тема", "Описание" и "Категория".
После загрузки данных объединяем поля "Тема" и "Описание" в одно поле для удобства дальнейшей обработки. Для этого предварительно необходимо заполнить чем-нибудь все пустые поля "Описание" (пустой строкой, например).
```
# Объявляем переменную issues типа DataFrame
issues = pd.DataFrame()
# Добавляем в issues столбцы Theme, Description и Cat, присваивая им значения полей Тема, Описание и Категория из .xlsx файла. u’...’ — потому что ‘…’ есть utf
issues[['Theme', 'Description','Cat']] = pd.read_excel('issues.xlsx')[[u'Тема', u'Описание', u'Категория']]
# Заполняем пустые ячейки столбца Description пустой строкой
issues.Description.fillna('', inplace = True)
# Объединяем столбцы Theme и Description (пробел используем в качестве разделителя) в столбец Content
issues['Content'] = issues.Theme + ' ' + issues.Description
```
Итак, у нас есть переменная issues типа DataFrame, в которой мы будем работать со столбцами Content (объединенное поле для полей "Тема" и "Описание") и Cat (категория заявки). Перейдем к формализации содержания заявки (т.е. столбца Content).
Формализация содержания заявок
------------------------------
### Описание подхода к формализации
Как было сказано выше, первым делом необходимо формализовать текст заявки. Формализацию будем проводить следующим образом:
1. Разобьем содержание заявки на слова. Под словом понимаем последовательность из 2 или более символов, разделенную символами-разделителями (тире, дефис, точка, пробел, переход на новую строку и т.д.). В итоге для каждой заявки получим массив входящих в её содержание слов.
2. Из каждой заявки исключим "слова-паразиты", не несущие смысловую нагрузку (например, слова, входящие во фразы-приветствия: "здравствуйте", "добрый", "день" и т.д.);
3. Из полученных массивов составим словарь: набор слов, используемых для написания содержания всех заявок;
4. Далее составляем матрицу размером *(количество заявок)* x *(количество слов в словаре)*, в которой i-я ячейка в j-м столбце соответствует количеству вхождений в i-ю заявку j-го слова из словаря.
Матрица из п.4 есть формализованное описание содержания заявок. Говоря математизированным языком, каждая строка матрицы — координаты вектора соответствующей заявки в пространстве словаря. Для обучения алгоритма будем использовать полученную матрицу.
**Важный момент**: п.3 осуществляем после того, как выделим из обучающей выборки случайную подвыборку для контроля качества алгоритма (тестовую выборку). Это необходимо для того, чтобы лучше понимать, какое качество алгоритм покажет "в бою" на новых данных (например, не сложно реализовать алгоритм, который на обучающей выборке будет давать идеально верные ответы, но на любых новых данных будет работать не лучше random-а: такая ситуация называется переобучением). Отделение тестовой выборки именно до составления словаря важно потому, что если бы мы составляли словарь в том числе и на тестовых данных, то обученный на выборке алгоритм получился бы уже знакомым с неизвестными объектами. Выводы о его качестве на неизвестных данных будут некорректными.
Теперь покажем, как п.п. 1-4 выглядят в коде.
### Разбиваем содержание на слова и убираем слова-паразиты
Первым делом приведем все тексты к нижнему регистру (“принтер” и “Принтер” — одинаковые слова только для человека, но не для машины):
```
#объявляем функцию приведения строки к нижнему регистру
def lower(str):
return str.lower()
#применяем функцию к каждой ячейке столбца Content
issues['Content'] = issues.Content.apply(lower)
```
Далее определим вспомогательный словарь “слов-паразитов” (его наполнение производилось опытным итерационным путем для конкретной выборки заявок):
```
garbagelist = [u'спасибо', u'пожалуйста', u'добрый', u'день', u'вечер',u'заявка', u'прошу', u'доброе', u'утро']
```
Объявим функцию, которая разбивает текст каждой заявки на слова длиной 2 и более символов, а затем включает полученные слова, за исключением “слов-паразитов”, в массив:
```
def splitstring(str):
words = []
#разбиваем строку по символам из []
for i in re.split('[;,.,\n,\s,:,-,+,(,),=,/,«,»,@,\d,!,?,"]',str):
#берём только "слова" длиной 2 и более символов
if len(i) > 1:
#не берем слова-паразиты
if i in garbagelist:
None
else:
words.append(i)
return words
```
Для разбиения текста на слова по символам-разделителям используется библиотека регулярных выражений re и её метод split. В метод split передается массив символов-разделителей (набор символов-разделителей пополнялся итерационно-опытным путем) и строка, подлежащая разбиению.
Применяем объявленную функцию к каждой заявке. На выходе получаем исходный DataFrame, в котором появился новый столбец Words с массивом слов (за исключением “слов-паразитов”), из которых состоит каждая заявка.
```
issues['Words'] = issues.Content.apply(splitstring)
```
### Составляем словарь
Теперь приступим к составлению словаря входящих в содержание всех заявок слов. Но перед этим, как писали выше, разделим обучающую выборку на контрольную (так же известную как "тестовая", "отложенная") и ту, на которой будем обучать алгоритм.
Разделение выборки осуществляем методом **train\_test\_split** модуля **model\_selection** библиотеки **Scikit-learn**. В метод передаем массив с данными (тексты заявок), массив с метками (категории заявок) и размер тестовой выборки (обычно выбирают 30% от всей). На выходе получаем 4 объекта: данные для обучения, метки для обучения, данные для контроля и метки для контроля:
```
issues_train, issues_test, labels_train, labels_test = model_selection.train_test_split(issues.Words, issues.Cat, test_size = 0.3)
```
Теперь объявим функцию, которая составит словарь по данным, оставленным на обучение (**issues\_train**), и применим функцию в этим данным:
```
def WordsDic(dataset):
WD = []
for i in dataset.index:
for j in xrange(len(dataset[i])):
if dataset[i][j] in WD:
None
else:
WD.append(dataset[i][j])
return WD
#применяем функцию к данным
words = WordsDic(issues_train)
```
Итак, мы составили словарь из слов, составляющих тексты всех заявок из обучающей выборки (за исключением заявок, оставленных на контроль). Словарь записали в переменную words. Размер массива words получился равным 12015-м элементов (т.е. слов).
### Переводим содержание заявок в пространство словаря
Перейдем к заключительному шагу подготовки данных для обучения. А именно: составим матрицу размера *(количество заявок в выборке)* x *(количество слов в словаре)*, где в i-й строке j-го столбца находится количество вхождений j-го слова из словаря в i-ю заявку из выборки.
```
#объявляем матрицу размером len(issues_train) на len(words), заполняем её нулями
train_matrix = np.zeros((len(issues_train),len(words)))
#заполняем матрицу, проставляя в [i][j] количество вхождений j-го слова из words в i-й объект обучающей выборки
for i in xrange(train_matrix.shape[0]):
for j in issues_train[issues_train.index[i]]:
if j in words:
train_matrix[i][words.index(j)]+=1
```
Теперь у нас есть всё необходимое для обучения: матрица **train\_matrix** (формализованное содержание заявок в виде координат векторов, соответствующих заявкам, в пространстве словаря, составленного по всем заявкам) и метки **labels\_train** (категории заявок из оставленной на обучение выборки).
Обучение
========
Перейдем к обучению алгоритмов на размеченных данных (т.е. таких данных, для которых известны правильные ответы: матрица *train\_matrix* с метками *labels\_train*). В этом разделе будет мало кода, так как большинство методов машинного обучения реализовано в библиотеке Scikit-learn. Разработка своих методов может быть полезной для усвоения материала, но с практической точки зрения в этом нет потребности.
Ниже постараюсь простым языком изложить принципы конкретных методов машинного обучения.
О принципах выбора лучшего алгоритма
------------------------------------
Никогда не знаешь, какой алгоритм машинного обучения будет давать лучший результат на конкретных данных. Но, понимая задачу, можно определить набор наиболее подходящих алгоритмов, чтобы не перебирать все существующие. Выбор алгоритма машинного обучения, который будет использоваться для решения задачи, осуществляется через сравнение качества работы алгоритмов на обучающей выборке.
Что считать качеством алгоритма, зависит от задачи, которую вы решаете. Выбор метрики качества — отдельная большая тема. В рамках классификации заявок была выбрана простая метрика: точность (accuracy). Точность определяется как доля объектов в выборке, для которых алгоритм дал верный ответ (поставил верную категорию заявки). Таким образом, мы выберем тот алгоритм, который будет давать бОльшую точность в предсказании категорий заявок.
Важно сказать о таком понятии, как гиперпараметр алгоритма. Алгоритмы машинного обучения имеют внешние (т.е. такие, которые не могут быть выведены аналитически из обучающей выборки) параметры, определяющие качество их работы. Например в алгоритмах, где требуется рассчитать расстояние между объектами, под расстоянием можно понимать разные вещи: [манхэттенское расстояние](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D1%80%D0%BE%D0%B4%D1%81%D0%BA%D0%B8%D1%85_%D0%BA%D0%B2%D0%B0%D1%80%D1%82%D0%B0%D0%BB%D0%BE%D0%B2), классическую [евклидову метрику](https://ru.wikipedia.org/wiki/%D0%95%D0%B2%D0%BA%D0%BB%D0%B8%D0%B4%D0%BE%D0%B2%D0%B0_%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D0%BA%D0%B0) и т.д.
У каждого алгоритма машинного обучения свой набор гиперпараметров. Выбор лучших значений гиперпараметров осуществляется, как ни странно, перебором: для каждой комбинации значений параметров вычисляется качество алгоритма и далее для данного алгоритма используется лучшая комбинация значений. Процесс затратный с точки зрения вычислений, но куда деваться.
Для определения качества алгоритма на каждой комбинации гиперпараметров используется кросс-валидация. Поясню, что это такое. Обучающая выборка разбивается на N равных частей. Алгоритм последовательно обучается на подвыборке из N-1 частей, а качество считается на одной отложенной. В итоге каждая из N частей 1 раз используется для подсчета качества и N-1 раз для обучения алгоритма. Качество алгоритма на комбинации параметров считается как среднее между значениями качества, полученными при кросс-валидации. Кросс-валидация необходима для того, чтобы мы могли больше доверять полученному значению качества (при усреднении мы нивелируем возможные “перекосы” конкретного разбиения выборки). Чуть подробнее [сами знаете где](https://en.wikipedia.org/wiki/Cross-validation_(statistics)).
Итак, для выбора наилучшего алгоритма для каждого алгоритма:
1. Перебираются все возможные комбинации значений гиперпараметров (у каждого алгоритма свой набор гиперпараметров и их значений);
2. Для каждой комбинации значений гиперпараметров с использование кросс-валидации вычисляется качество алгоритма;
3. Выбирается тот алгоритм и с той комбинацией значений гиперпараметров, что показывает наилучшее качество.
С точки зрения программирования описанного выше алгоритма нет ничего сложного. Но и в этом нет потребности. В библиотеке *Scikit-learn* есть готовый метод подбора параметров по сетке (метод *GridSearchCV* модуля *grid\_search*). Все что нужно — передать в метод алгоритм, сетку параметров и число N (количество частей, на которые разбиваем выборку для кросс-валидации; их ещё называют "folds").
В рамках решения задачи было выбрано 2 алгоритма: k ближайших соседей и композиция случайных деревьев. О каждом из них рассказ далее.
k ближайших соседей (kNN)
-------------------------
Метод k ближайших соседей наиболее прост в понимании. Заключается он в следующем.
Есть обучающая выборка, данные в которой уже формализованы (подготовлены к обучению). Т.е объекты представлены в виде векторов какого-либо пространства. В нашем случае заявки представлены в виде векторов пространства словаря. Для каждого вектора обучающей выборки известен правильный ответ.
Для каждого нового объекта вычисляются попарные расстояния между этим объектом и объектами обучающей выборки. Затем берутся k ближайших объектов из обучающей выборки и для нового объекта возвращается ответ, который преобладает в подвыборке из k ближайших объектов (для задач, где нужно предсказать число, можно брать среднее значение из k ближайших).
Алгоритм можно развить: давать бОльший вес значению метки на более близком объекте. Но для задачи классификации заявок делать этого не будем.
Гиперпараметрами алгоритма в рамках нашей задачи являются число k (по скольки ближайшим соседям будем делать вывод) и определение расстояния. Количество соседей перебираем в диапазоне от 1 до 7, определение расстояния выбираем из манхэттенского расстояния (сумма модулей разности координат) и евклидовой метрики (корень из суммы квадратов разности координат).
Выполняем незамысловатый код:
```
%%time
#задаем сетку для подбора гиперпараметров
param_grid = {'n_neighbors': np.arange(1,8), 'p': [1,2]}
#задаем количество fold-ов для кросс-валидации
cv = 3
#объявляем классификатор
estimator_kNN = neighbors.KNeighborsClassifier()
#передаем сетку, классификатор и количество fold-ов в метод подбора параметров по сетке
optimazer_kNN = GridSearchCV(estimator_kNN, param_grid, cv = cv)
#запускаем подбор параметров по сетке на обучающей выборке
optimazer_kNN.fit(train_matrix, labels_train)
#смотрим лучшие параметры и качество алгоритма на лучших параметрах
print optimazer_kNN.best_score_
print optimazer_kNN.best_params_
```
Через 2 минуты 40 секунд узнаем, что лучшее качество в 53,23% показывает алгоритм на 3 ближайших соседях, определенных по манхэттенскому расстоянию.
Композиция случайных деревьев
-----------------------------
### Решающие деревья
Решающие деревья — ещё один алгоритм машинного обучения. Обучение алгоритма представляет собой пошаговое разбиение обучающей выборки на части (чаще всего на две, но в общем случае это не обязательно) по какому-либо признаку. Вот простой пример, иллюстрирующий работу решающего дерева:
У решающего дерева есть внутренние вершины (в которых принимаются решения о дальнейшем разбиении выборки) и финальные вершины (листы), по которым дается прогноз попавшим туда объектам.
В решающей вершине проверяется простое условие: соответствие какого-то (об этом далее) j-го признака объекта условию xj больше или равно какому-то t. Объекты, удовлетворяющие условию, отправляются в одну ветку, а не удовлетворяющие — в другую.
При обучении алгоритма можно было бы разбивать обучающую выборку до тех пор, пока во всех вершинах не останется по одному объекту. Такой подход даст отличный результат на обучающей выборке, но на неизвестных данных получится "шляпа". Поэтому важно определить так называемый "критерий останова" — условие, при котором вершина становится листом и дальнейшее ветвление этой вершины приостанавливается. Критерий останова зависит от задачи, вот некоторые типы критериев: минимальное количество объектов в вершине и ограничение на глубину дерева. В решении поставленной задачи использовался критерий минимального количества объектов в вершине. Число, равное минимальному количеству объектов, является гиперпараметром алгоритма.
Новые (требующие предсказания) объекты прогоняются по обученному дереву и попадают в соответствующий им лист. Для объектов, попавших в лист, даем следующий ответ:
1. Для задач классификации возвращаем самый распространенный в этом листе класс объектов обучающей выборки;
2. Для задач регрессии (т.е. таких, где ответом является число) возвращаем среднее значение на объектах обучающей выборки из этого листа.
Осталось поговорить о том, как выбирать для каждой вершины признак j (по какому признаку разбиваем выборку в конкретной вершине дерева) и соответствующий этому признаку порог t. Для этого вводят так называемый критерий ошибки Q(Xm,j,t). Как видно, критерий ошибки зависит от выборки Xm (та часть обучающей выборки, что дошла до рассматриваемой вершины), параметра j, по которому будет разбиваться выборка Xm в рассматриваемой вершине и порогового значения t. Необходимо подобрать такое j и такое t, при котором критерий ошибки будет минимальным. Так как возможный набор значений j и t для каждой обучающей выборки ограничен, задача решается перебором.
Что такое критерий ошибки? В черновой версии статьи на этом месте было много формул и сопровождающих объяснений, рассказ про критерий информативности и его частные случаи (критерий Джинни и энтропийный критерий). Но статья получилась и так раздутой. Желающие разобраться в формальностях и математике смогут почитать обо всем в интернете (например, [здесь](http://www.machinelearning.ru/wiki/images/8/89/Sem3_trees.pdf)). Ограничусь "физическим смыслом" на пальцах. Критерий ошибки показывает уровень "разнообразия" объектов в получающихся после разбиения подвыборках. Под "разнообразием" в задачах классификации подразумевается разнообразие классов, а в задачах регрессии (где предсказываем числа) — дисперсия. Таким образом, при разбиении выборки мы хотим максимальным образом уменьшить "разнообразие" в получающихся подвыборках.
С деревьями разобрались. Перейдем к композиции деревьев.
### Композиция решающих деревьев
Решающие деревья могут выявить очень сложные закономерности в обучающей выборке. Но чем лучший результат обучающие деревья показывают на обучении, тем худший результат они покажут на новых данных — деревья переобучаются. Для устранения этой проблемы придуман механизм объединения обучающих деревьев в композиции (леса).
Для построения композиции деревьев берется N обученных деревьев и их результат “усредняется”. Для задач регрессии (там, где предсказываем число) берется среднее значение предсказанных чисел, а для задач классификации — самый популярный (из N предсказаний) предсказанный класс.
Таким образом, для построения леса необходимо сначала обучить N решающих деревьев. Но делать это на одной и той же обучающей выборке бессмысленно: мы получим N одинаковых алгоритмов и результат усреднения будет равен результату любого из них. Поэтому для обучения базовых деревьев используется рандомизация: обучение каждого базового дерева производится по случайной подвыборке объектов исходной обучающей выборки и/или по случайному набору параметров (т.е. для обучения каждого базового алгоритма берутся не все параметры объектов, а только случайный набор определенного размера). Но и этого бывает недостаточно для построения независимых алгоритмов — применяют рандомизацию признаков для разбиения на каждой вершине (т.е. на каждой вершине каждого дерева признак выбирают не из всего набора, а из случайной подвыборки признаков определенного размера; важно, что для каждой вершины каждого дерева случайная подвыборка — своя). Поэтому алгоритм и называется композицией **случайных** деревьев.
Перейдем наконец-то к практике! При обучении алгоритма будем искать лучшие значения для 2-х гиперпараметров: минимального количества объектов в узле (гиперпараметр для дерева) и количества базовых алгоритмов (гиперпараметр для леса).
Запускаем код:
```
%%time
#задаем сетку для подбора гиперпараметров
param_grid = {'n_estimators': np.arange(20,101,10), 'min_samples_split': np.arange(4,11, 1)}
#задаем количество fold-ов для кросс-валидации
cv = 3
#объявляем классификатор
estimator_tree = ensemble.RandomForestClassifier()
#передаем сетку, классификатор и количество fold-ов в метод подбора параметров по сетке
optimazer_tree = GridSearchCV(estimator_tree, param_grid, cv = cv)
#запускаем подбор параметров по сетке на обучающей выборке
optimazer_tree.fit(train_matrix, labels_train)
#смотрим лучшие параметры и качество алгоритма на лучших параметрах
print optimazer_tree.best_score_
print optimazer_tree.best_params_
```
Через 3 минуты 30 секунд узнаем, что лучшее качество в 65,82% показывает алгоритм из 60 деревьев, для которых минимальное количество объектов в узле равно 4.
Результат
=========
Результаты на отложенной выборке
--------------------------------
Теперь проверим работу двух обученных алгоритмов на отложенной (тестовой, контрольной — как её только не называют) выборке.
Для этого составим матрицу test\_matrix, являющуюся проекцией объектов отложенной выборки на пространство словаря, составленного по обучающей выборке (т.е. составляем такую же матрицу, что и train\_matrix, только для отложенной выборки).
```
#Создаем матрицу размером len(issues_test) на len(words)
test_matrix = np.zeros((len(issues_test),len(words)))
#заполняем матрицу, проставляя в [i][j] количество вхождений j-го слова из words в i-й объект тестовой выборки
for i in xrange(test_matrix.shape[0]):
for j in issues_test[issues_test.index[i]]:
if j in words:
test_matrix[i][words.index(j)]+=1
```
Для получения качества алгоритмов используем метод accuracy\_score модуля metrics библиотеки Scikit-learn. Передаем в него предсказания на отложенной выборке каждого из алгоритмов и известные для отложенной выборки значения меток:
```
print u'Случайный лес:', accuracy_score(optimazer_tree.best_estimator_.predict(test_matrix), labels_test)
print u'kNN:', accuracy_score(optimazer_kNN.best_estimator_.predict(test_matrix), labels_test)
```
Получаем 51,39% на алгоритме k ближайших соседей и 73,46% на композиции случайных деревьев.
Сравнение с "глупыми" алгоритмами
---------------------------------
Целью эксперимента было получение результата, “в разы” лучшего, чем random. На самом деле речь шла о “глупых” алгоритмах, частным случаем которых является random. В общем случае, “глупые” алгоритмы это такие алгоритмы, построить которые можно без сколь-нибудь серьезного анализа обучающей выборки.
Сравним полученное качество с 3-мя видами “глупых” алгоритмов:
1. Равномерный random;
2. Всегда выдаем самый популярный класс из обучающей выборки;
3. Random, пропорциональный плотности классов в обучающей выборке.
Равномерный random на 14 классах дает примерно 100/14 \* 100% = 7,14% качество. Алгоритм, который всегда выдает самый популярный класс даст качество в 14,5% (такая доля у самого популярного класса в обучающей выборке). Для получения качества на пропорциональном random-е напишем простой код. Каждому объекту отложенной выборки алгоритм будет присваивать класс объекта из обучающей выборки, выбранный равномерным random-ом:
```
#импортируем библиотеку random
import random
#объявляем массив, куда будем складывать random-ные предсказания
rand_ans = []
#предсказываем
for i in xrange(test_matrix.shape[0]):
rand_ans.append(labels_train[labels_train.index[random.randint(0,len(labels_train))]])
#смотрим качество
print u'Пропорциональный random:', accuracy_score(rand_ans, labels_test)
```
Получаем 14,52%.
Итак, используя не самые сложные методы мы получили качество классификации в разы выше, чем дают “глупые” алгоритмы. Ура!
Что дальше?
===========
Для промышленного применения машинного обучения при классификации заявок, необходимо получить качество не ниже 90% — такой ориентир дают потенциальные потребители. Результаты эксперимента показывают, что такое качество может быть достигнуто. Ведь даже при подготовке данных к обучению мы не использовали такие “классические” методы подготовки текстов как [стемминг](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BC%D0%BC%D0%B8%D0%BD%D0%B3) и ранжирование слов при попадании в словарь (если слово встречается пару раз в выборке, оно скорее всего мусорное и его можно исключить). К тому-же, в словаре для одного и того же слова было несколько написаний (например: "п*е*чать", "п*и*чать", "печ*я*ть" и т.д.) — с этим тоже можно бороться (желательно в школе) и повышать качество алгоритма.
Кроме того, в эксперименте использовался только один параметр: текст. Если весь текст заявки это фраза "Не работает" или "Проблема", у нас не так много вариантов определить что случилось. У всех возможных категорий заявок одинаковая вероятность быть верным ответом. Но если мы знаем, что заявка пришла из бухгалтерии, а дата регистрации совпадает с датой квартального отчета, количество возможных вариантов резко сокращается.
В общем, можно инвестировать в разработку промышленного модуля классификации заявок для [Okdesk](https://www.okdesk.ru).
"Отлично! Работаем дальше!" (с)
Продолжение [Машинное обучение своими руками (часть 2). Сервис для классификации обращений в тех. поддержку](https://habrahabr.ru/company/okdesk/blog/342796/) | https://habr.com/ru/post/337278/ | null | ru | null |
# Пишем социальную сеть на Ruby on Rails. Часть 1
Кадр из фильма "Социальная Сеть"Другие статьи этой серии:
* [Пишем социальную сеть на Ruby on Rails. Часть 2](https://habr.com/ru/post/652657/)
Зачем и для кого эта статья?
----------------------------
Всем привет! Я Ruby on Rails Developer и еще совсем недавно я начинал свой путь в этой области. Я уже прошел первые шаги (о них я писал в данной [статье](https://habr.com/ru/post/591971/)), как выбор языка, изучение его основ, знакомство с фреймворком, первые pet-проекты, первые собеседования, первый оффер, первая компания. Но многие только начали идти по этому пути и именно для них эта статья. По своему опыту помню, как сложно искать гайды (большинство из них про создание книжных магазинов, личных блогов и т.д.), поэтому, надеюсь, многим понравиться идея создания соц сети.
Почему соц сеть и как будет идти процесс?
-----------------------------------------
Во-первых, мне самому было бы интересно реализация данного проекта. Во-вторых, я вдохновился книгой **Practical Rails Social Networking Sites by Alan Bradburne**. Можно было бы сделать все по книге, скажете вы. Но зачем тогда я и мои статьи? Книга 2007 года и версия ruby там 1.8, поэтому решения в большинстве своем будут неактуальны в наше время. К тому же, я не собираюсь делать все по книге, а лишь руководствоваться ей (дизайн буду использовать из нее с добавлением `bootsrap`). Во время разработки я буду использовать многие гемы, которые будут полезны для начинающих разработчиков. Но скажу сразу: эта серия статей не для самого старта. Некоторые базовые вещи (установка `ruby`, `rails`, что такое `MVC`, `git` и тому подобное) я буду пропускать, поэтому рекомендую отложить данный цикл статей и вернуться к нему чуть позже. Если вы опытный разработчик и читаете эту статью, буду очень признателен услышать ваше мнение. Касательно периодичности выхода статей и сколько именно их будет не могу сказать, так как планирую делать проект в свободное время от работы и параллельно писать статьи. Но буду стараться не откладывать в долгий ящик и делать все с хорошим темпом.
Создаем проект и делаем первичные настройки
-------------------------------------------
Перед тем, как мы начнем, установите следующие версии:
* `Ruby 3.0.3`
* `Rails 6.1.4.6`
* `MySQL 8.0`
* `Node 10.19`
* `Yarn 1.22.17`
Очень советую вам использовать `github` во время разработки данного проекта. Чуть позже мы с вами настроим `CI/CD` на нашем проекте, что будет крайне полезным для вас опытом. Теперь создадим наш проект. Я назову его `g_connect`, но вы можете использовать любое другое название (если выберите другое, везде, где я буду использовать `g_connect`, пишите свое).
```
rails new g_connect -d mysql
```
Теперь переходим в папку с проектом и займемся первичными настройками. Я всегда начинаю с `Gemfile` и некоторые гемы, которые точно буду использовать во время разработки.
```
#Gemfile
source 'https://rubygems.org'
git_source(:github) { |repo| "https://github.com/#{repo}.git" }
ruby '3.0.3'
gem 'aasm'
gem 'bootsnap', '>= 1.4.4', require: false
gem 'bootstrap'
gem 'devise'
gem 'jbuilder', '~> 2.7'
gem 'mysql2', '~> 0.5.2'
gem 'puma', '~> 5.0'
gem 'rails', '~> 6.1.4.6'
gem 'sass-rails', '>= 6'
gem 'slim'
gem 'turbolinks', '~> 5'
gem 'webpacker', '~> 5.0'
group :development, :test do
gem 'better_errors'
gem 'binding_of_caller'
gem 'byebug', platforms: %i[mri mingw x64_mingw]
gem 'factory_bot_rails'
gem 'faker'
gem 'rails-controller-testing'
gem 'rspec-rails'
gem 'rubocop'
gem 'rubocop-rails'
gem 'rubocop-rspec'
end
group :development do
gem 'annotate'
gem 'listen', '~> 3.3'
gem 'rack-mini-profiler', '~> 2.0'
gem 'spring'
gem 'web-console', '>= 4.1.0'
end
group :test do
gem 'capybara', '>= 3.26'
gem 'rspec_junit_formatter'
gem 'selenium-webdriver'
gem 'simplecov', require: false
gem 'webdrivers'
end
gem 'tzinfo-data', platforms: %i[mingw mswin x64_mingw jruby]
```
Давайте я поясню, для чего некоторые из этих гемов (более подробно рекомендую перед стартом ознакомиться с документацией):
* [gem 'aasm'](https://github.com/aasm/aasm) - его мы будем использовать для транзакций между состояниями
* [gem 'bootstrap'](https://github.com/twbs/bootstrap-rubygem) - это нам нужно будет для нашего дизайна (я делаю упор на бэк и совсем немного буду уделять время фронту, но в самом конце может и придет вдохновение на наведение красоты)
* [gem 'devise'](https://github.com/heartcombo/devise) - аутентификация (коротко и ясно, будет еще гем для авторизации, но я еще не выбрал, какой)
* [gem 'slim'](https://github.com/slim-template/slim) - сэкономим время на написании html-тегов
* [gem 'better\_errors'](https://github.com/BetterErrors/better_errors) - красивый вывод ошибок в браузере (например, роут указали неправильный)
* [gem 'factory\_bot\_rails'](https://github.com/thoughtbot/factory_bot_rails) - шаблон, который будем использовать в наших тестах
* [gem 'faker'](https://github.com/faker-ruby/faker) - для создания фейковых данных
* [gem 'rspec-rails](https://github.com/rspec/rspec-rails) - это подключаем среду тестирования `RSpec` для нашего проекта
* [gem 'rubocop'](https://github.com/rubocop/rubocop) - проверяем, насколько хорошо написан наш код
* [gem 'annotate'](https://github.com/ctran/annotate_models) - для автоматической аннотации наших моделей (зачем переключаться между моделей и миграцией, если есть этот гем)
* [gem 'simplecov'](https://github.com/simplecov-ruby/simplecov) - для просмотра, все ли мы покрыли тестами
Теперь нужно установить все гемы и их зависимости, поэтому запускаем `bundle` в нашем терминале (кстати да, забыл сказать, что использую `Ubuntu`, поэтому для `MacOS/Windows`(вот винду вообще не трогайте лучше при разработке на `ruby`, но уж если оч хочется) смотрите некоторые моменты самостоятельно). Также можем удалить папку `test`, она не понадобиться (ведь будем писать `rspec`-и).
После этого настроим нашу БД. В файле `config/database.yml` укажите свои username и password (я стандартно делал `root/root`). После этого запускаем следующее (если кто-то не знает, то эта одна команда сразу же выполняет `db:create`, `db:schema:load` и `db:seed`):
```
rails db:setup
```
Некоторые из наших гемов требуют дополнительной настройки. Ими мы сейчас и займемся (`devise` также требует дополнительной настройки, но им мы займемся позже, когда будем делать аутентификацию). Начнем с `bootstrap`. Переходим в файл `app/assets/stylesheets/application.scss` (файл может вначале иметь расширение `.css`, поэтому исправьте его на `.scss`) и добавляем следующую строчку:
```
/*app/assets/stylesheets/application.scss*/
@import "bootstrap";
```
Теперь настроим `annotate`. Для этого в терминале запустите следующую команду:
```
rails g annotate:install
```
Теперь нужно настроить `rspec`:
```
rails g rspec:install
```
Также для наших тестов нам понадобится настройка `factory_bot_rails` и `simplecov`. В нашей папке `spec` создаем папку `support`, а в ней создаем файл `factory_bot.rb` со следующим кодом:
```
#spec/support/factory_bot.rb
RSpec.configure do |config|
config.include FactoryBot::Syntax::Methods
end
```
Теперь переходим в наш `spec/rails_helper.rb`. Здесь мы подключим наш файл для `factory_bot`, а так же подключим `simplecov` (две строчки для подключения `simplecov` должны быть в самом начале файла).
```
#spec/rails_helper.rb
require 'simplecov'
SimpleCov.start 'rails'
require_relative './support/factory_bot'
```
С настройкой гемов пока что закончили. Если вы хотите проверить процент покрытия тестами, то можете запустить `xdg-open coverage/index.html` и вот она магия. Но я бы хотел добавить еще пару моментов. Первый - `shared_context.rb` для тестов наших моделей. В папке `spec/support` создайте `shared_context.rb`
```
#spec/support/shared_context.rb
RSpec.shared_examples 'creates_object_for' do |model_name|
subject { FactoryBot.build(model_name) }
it 'creates object' do
expect { subject.save }.to change { described_class.count }.by(1)
end
end
RSpec.shared_examples 'not_create_object_for' do |model_name, parameter|
subject { described_class.create(attributes) }
let(:attributes) { FactoryBot.attributes_for(model_name, parameter) }
it 'does not create object' do
expect { subject.save }.to change { described_class.count }.by(0)
end
it 'raise RecordInvalid error' do
expect { subject.save! }.to raise_error(ActiveRecord::RecordInvalid)
end
end
```
Наш `shared_context` будет играть роль шаблона для тестирования моделей. В нем мы опишем, что должно происходить, если данные валидны и объект создаётся, и наоборот, что будет происходить, если какие-то данные невалидны либо отсутствуют и объект не будет создаваться. Это заметно упростит написание тестов для моделей, потом на практике вы в этом убедитесь. Теперь давайте подключим его в наш `spec_helper.rb`
```
#spec/spec_helper.rb
require_relative './support/shared_context'
```
И последнее по настройкам перед стартом: чутка дизайна. Перейдите в `app/views/layouts/application.html.erb`. Измените расширение `.erb` на `.slim` и сделайте вот так:
```
#app/views/layouts/application.html.slim
doctype html
html
head
meta content='text/html; charset=UTF-8' http-equiv='Content-Type'
title G-Connect
= csrf_meta_tags
= csp_meta_tag
= stylesheet_link_tag 'application', media: 'all', 'data-turbolinks-track': 'reload'
= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload'
body
#container
#header
#sidemenu
= render 'application/sidemenu'
#content
= yield
```
Как по мне, это намного лучше смотрится, чем `.html.erb`. Если вы до этого никогда не использовали `.slim`, то используйте вот [этот](https://erb2slim.com/) ресурс для перевода из `.html.erb` в `.html.slim`. Далее в папке `app/views` создаем папку application, а в ней файл `_sidemenu.html.slim` и внутри него пока что только следующие строчки:
```
#app/views/layouts/_sidemenu.html.slim
ul
li
= link_to 'Home', '/', class: 'btn btn-sm btn-light'
```
Затем переходим в `app/assets/stylesheets/application.scss` и добавляем следующее:
```
/*app/assets/stylesheets/application.scss*/
body {
margin: 0;
padding: 0;
background-color: #f0ffff;
font-family: Arial, Helvetica, sans-serif;
}
#header {
background-color: #f0ffff;
height: 60px;
margin-top: 10px;
text-align: left;
padding-top: 1px;
}
#container {
width: 760px;
min-width: 760px;
margin: 0 auto;
padding: 0px;
}
#sidemenu {
font-size: 80%;
float: left;
width: 100px;
padding: 0px;
}
#sidemenu ul {
list-style: none;
margin-left: 0px;
padding: 0px;
}
a {
color: #b00;
}
a:hover {
background-color: #b00; color: #f0ffff;
}
#content {
float: right;
width: 650px;
}
th {
background-color: #933;
color: #f0ffff;
}
tr.odd {
background-color: #fcc;
}
tr.even {
background-color: #ecc;
}
```
Пока совсем простенько (`css` взят из книги), но, как я и говорил ранее, я делаю упор на бэк. Когда первичная работа окончена, можем двигаться дальше. Может залить все, что мы с вами сделали, на `github` и делать новые вещи уже в другой ветке. Рекомендую перед этим сделать проверку `rubocop`-ом (можете добавить специальное расширение для вашей `IDE` и он сразу будет подсвечивать вам файлы, в которых есть недочеты).
Создание модели страниц
-----------------------
Первую модель мы сделаем для страниц. У нее будут следующие поля
| | |
| --- | --- |
| Имя поля | Тип |
| `id` | `integer` |
| `title` | `string` |
| `permalink` | `string` |
| `body` | `text` |
`Permalink` будет составляться из нашего `title`, только будет иметь более красивый вид, чтобы использовать его в качестве `url`. Давайте создадим модель.
```
rails g model Page
```
Помимо модели у нас сгенерировалась миграция и два файла для тестов, к ним мы вернемся чуть позже. Миграция находится в папке `db/migrate`. Давайте начнем с нее:
```
#db/migrate/date_time_create_pages.rb
class CreatePages < ActiveRecord::Migration[6.1]
def change
create_table :pages do |t|
t.string :title, null: false
t.string :permalink
t.text :body, null: false
end
end
end
```
После этого запускаем `rails db:migrate` (наш `annotate` сразу же показывает, какие файлы были аннотированы) и переходим в нашу модель. Здесь мы пропишем наши валидации, а так же метод для получения нашего `permalink` (его мы будем вызывать с помощью коллбэка `after_create`). В этом методе я буду использовать регулярные выражения, для помощи с их составлением я всегда использую [Rubular](https://rubular.com/).
```
#app/model/page.rb
class Page < ApplicationRecord
after_create :clean_url
validates_presence_of :title, :body
validates :title, length: { in: 3..250 }
validates :body, length: { in: 3..100_00 }
private
def clean_url
return unless self.permalink.nil?
url = title.downcase.gsub(/\s+/, '_').gsub(/[^a-zA-Z0-9_]+/, '')
self.permalink = url
save
end
end
```
Теперь предлагаю заняться нашими тестами. Начнем с файла `spec/factories/pages.rb`
```
#spec/factories/pages.rb
FactoryBot.define do
factory :page do
title { 'Test' }
body { 'Test' }
end
end
```
После этого можем заняться непосредственно написанием тестов. Именно в этом файле нам и пригодится наш написанный ранее `spec/supprot/shared_context.rb`.
```
#spec/models/page_spec.rb
require 'rails_helper'
RSpec.describe Page, type: :model do
describe '.create' do
context 'with valid attributes' do
include_examples 'creates_object_for', :page
end
context 'with invalid attributes' do
context 'with short title' do
include_examples 'not_create_object_for', :page, title: 'te'
end
context 'with too long title' do
include_examples 'not_create_object_for', :page, title: Faker::String.random(length: 253)
end
context 'with short body' do
include_examples 'not_create_object_for', :page, body: 'te'
end
context 'with too long body' do
include_examples 'not_create_object_for', :page, body: Faker::String.random(length: 100_02)
end
end
context 'with missing attributes' do
context 'with missing title' do
include_examples 'not_create_object_for', :page, title: nil
end
context 'with missing body' do
include_examples 'not_create_object_for', :page, body: nil
end
end
end
end
```
Думаю, здесь не нужно никаких пояснений, лишь отмечу, что private методы не нуждаются в тестировании, поэтому здесь и нет тестов для нашего `clean_url`. Можем запустить `rspec` в нашем терминале и убедиться, что все наши тесты проходят без ошибок. Когда с моделью и тестами для них мы разобрались, предлагаю заняться контроллером. Я не использую генератор для контроллеров, поэтому создаем файл `pages_controller.rb` в нашей папке `app/controllers`. Здесь мы пропишем следующее:
```
#app/controllers/pages_controller.rb
class PagesController < ApplicationController
before_action :find_page, only: %i[show edit update destroy]
def index
@pages = Page.all
end
def show; end
def new
@page = Page.new
end
def create
@page = Page.create(page_params)
if @page.save
redirect_to pages_path, notice: 'Page created'
else
render :new
end
end
def edit; end
def update
if @page.update(page_params)
redirect_to page_path(@page), notice: 'Page updated'
else
render :edit
end
end
def destroy
@page.destroy
redirect_to pages_path, notice: 'Page deleted'
end
private
def find_page
@page = Page.find(params[:id])
end
def page_params
params.require(:page).permit(:title, :permalink, :body)
end
end
```
Здесь все с больше абсолютно стандартное, поэтому также не буду заострять на этом внимание. Теперь нужно добавить роуты для нашего контроллера:
```
#config/routes.rb
Rails.application.routes.draw do
root 'pages#index'
resources :pages
end
```
Теперь давайте покроим тестами наш контроллер. Для это в папке `spec` создаем папку `controllers` и там же сразу создаем файл `pages_controller_spec.rb`
```
#spec/controllers/pages_controller_spec.rb
require 'rails_helper'
RSpec.describe PagesController, type: :controller do
describe 'GET #index' do
let(:pages) { [FactoryBot.create(:page)] }
it 'returns all pages' do
get :index
expect(response).to render_template('index')
expect(response).to have_http_status(:ok)
expect(assigns(:pages)).to eq(pages)
end
end
describe 'GET #show' do
let(:page) { FactoryBot.create(:page) }
it 'assigns page' do
get :show, params: { id: page.id }
expect(response).to render_template('show')
expect(response).to have_http_status(:ok)
expect(assigns(:page)).to eq(page)
end
end
describe 'GET #new' do
it 'returns render form for creating new page' do
get :new
expect(response).to render_template('new')
expect(response).to have_http_status(:success)
end
end
describe 'POST #create' do
let(:page_params) { FactoryBot.attributes_for(:page) }
it 'creates new page' do
post :create, params: { page: page_params }
expect(response).to redirect_to('/pages')
expect(response).to have_http_status(:found)
end
it 'doesn`t create new page' do
post :create, params: { page: page_params.except(:title) }
expect(response).to render_template('new')
end
end
describe 'PUT #update' do
let(:page) { FactoryBot.create(:page) }
it 'updates the requested page' do
put :update, params: { id: page.id, page: { title: 'brbrbr' } }
expect(response).to redirect_to("/pages/#{page.id}")
expect(response).to have_http_status(:found)
end
it 'doesn`t update page' do
put :update, params: { id: page.id, page: { title: '' } }
expect(response).to render_template('edit')
end
end
describe 'DELETE #destroy' do
let(:page) { FactoryBot.create(:page) }
it 'destroys page' do
delete :destroy, params: { id: page.id }
expect(response).to redirect_to('/pages')
end
end
end
```
Теперь же предлагаю сделать визуал для нашего контроллера. Переходим в `app/views` и создаем там папку `pages`, а в ней 5 файлов: `_form.htm.slim`, `new.html.slim`, `edit.html.slim`, `show.html.slim` и `index.html.slim`. Теперь пройдемся по каждому из них. В нашем `_form.htm.slim` будет находиться форма, которую мы будем заполнять для создания или изменения наших `Pages`. Эту форму мы будем рендерить в наших `new` и `edit` соответственно.
```
#app/views/pages/_form.html.slim
= form_with(model: page, local: true) do |f|
.form-group
= f.label :title
= f.text_field :title
.form-group
= f.label :body
= f.text_area :body
.form-group
= f.submit 'Submit', class: 'btn btn-success'
```
```
#app/views/pages/new.html.slim
h1 New Page
= render 'form', page: @page
= link_to 'Back', :back, class: 'btn btn-sm btn-primary'
```
```
#app/views/pages/edit.html.slim
h1 Edit Page
= render 'form', page: @page
= link_to 'Back', :back, class: 'btn btn-sm btn-primary'
```
Теперь займемся `show` и `index`:
```
#app/views/pages/show.html.slim
p
strong Title:
= @page.title
p
strong Body:
= @page.body
= link_to 'Edit', edit_page_path(@page), class: 'btn btn-sm btn-success'
'
= link_to 'Delete', page_path(@page), method: :delete, class: 'btn btn-sm btn-danger', data: { confirm: 'Are you sure?' }
'
= link_to 'Back', :back, class: 'btn btn-sm btn-primary'
```
```
#app/views/pages/index.html.slim
h2 Pages
ul
- @pages.each do |page|
li
= page.permalink
|:
= page.title
|
p
= link_to 'Show', page_path(page), class: 'btn btn-sm btn-info'
p
= link_to 'Create new page', new_page_url, class: 'btn btn-sm btn-primary'
```
И последняя вещь на сегодня - немного подправим `_sidemenu.html.slim`
```
#app/views/application/_sidemenu.html.slim
ul
li
= link_to 'Home', root_path, class: 'btn btn-sm btn-light'
```
Думаю, на сегодня уже достаточно. Итак довольно объемная статья получилась. Проверьте все `rubocop`-ом, исправьте недочеты, если нужно, и можете смело заливать на ваш `github`. В следующей статье мы добавим пользователей, `devise` и настроим `CI/CD`. Надеюсь вам всем было интересно читать эту статью. Если есть какие-то замечания либо же предложения - смело пишите в комментариях. Желаю всем поменьше ошибок в коде и побольше интересных проектов! | https://habr.com/ru/post/652035/ | null | ru | null |
# Игра Жизнь и преобразование Фурье
Многие слышали о великом и ужасном быстром преобразовании Фурье (БПФ / FFT — fast fourier transform) — но как его можно применять для решения практических задач за исключением [JPEG](http://habrahabr.ru/post/102521/)/MPEG сжатия и разложения звука по частотам (эквалайзеры и проч.) — зачастую остается неясным вопросом.
Недавно я наткнулся на интересную реализацию игры «Жизнь» Конвея, использующую быстрое преобразование Фурье — и надеюсь, оно поможет вам понять применимость этого алгоритма в весьма неожиданных местах.
Правила
=======
Вспомним правила классической «Жизни» — на поле с квадратными клетками, живая клетка погибает если у неё больше 3 или меньше 2 соседей, и если у пустой клетки ровно 3 соседей — она рождается. Соответственно, для эффективной реализации алгоритма нужно быстро считать количество соседей вокруг клетки.
Алгоритмов для этого существует целая куча (в том числе и моя [JS реализация](http://habrahabr.ru/post/144237/)). Но есть у задачи и математическое решение, которое может давать хорошую скорость для плотно заполненных полей, и быстро уходит в отрыв с ростом сложности правил и площади/объема суммирования — например в Smoothlife-подобных ([1](http://habrahabr.ru/post/154509/),[2](http://sourceforge.net/projects/smoothlife/)), и 3D вариантах.
Реализация на БПФ
=================
Идея алгоритма следующая:1. Формируем матрицу суммирования (filter), где 1 стоят в ячейках, сумму которых нам нужно получить (8 единиц, остальные нули). Выполняем над матрицей прямое преобразование Фурье (это нужно сделать только 1 раз).
2. Выполняем прямое преобразование Фурье над матрицей с содержимым игрового поля.
3. Перемножаем каждый элемент результата на соответствующий элемент матрицы «суммирования» из пункта 1.
4. Выполняем обратное преобразование Фурье — и получаем матрицу с нужной нам суммой количества соседей для каждой клетки.
Весь этот процесс называется сверткой / сonvolution.
**Реализация на C++**
```
//Author: Mark VandeWettering http://brainwagon.org/2012/10/11/crazy-programming-experiment-of-the-evening/
#include
#include
#include
#include
#include
#include
#define SIZE (512)
#define SHIFT (18)
fftw\_complex \*filter ;
fftw\_complex \*state ;
fftw\_complex \*tmp ;
fftw\_complex \*sum ;
int
main(int argc, char \*argv[])
{
fftw\_plan fwd, rev, flt ;
fftw\_complex \*ip, \*jp ;
int x, y, g ;
srand48(getpid()) ;
filter = (fftw\_complex \*) fftw\_malloc(SIZE \* SIZE \* sizeof(fftw\_complex)) ;
state = (fftw\_complex \*) fftw\_malloc(SIZE \* SIZE \* sizeof(fftw\_complex)) ;
tmp = (fftw\_complex \*) fftw\_malloc(SIZE \* SIZE \* sizeof(fftw\_complex)) ;
sum = (fftw\_complex \*) fftw\_malloc(SIZE \* SIZE \* sizeof(fftw\_complex)) ;
flt = fftw\_plan\_dft\_2d(SIZE, SIZE,
filter, filter, FFTW\_FORWARD, FFTW\_ESTIMATE) ;
fwd = fftw\_plan\_dft\_2d(SIZE, SIZE,
state, tmp, FFTW\_FORWARD, FFTW\_ESTIMATE) ;
rev = fftw\_plan\_dft\_2d(SIZE, SIZE,
tmp, sum, FFTW\_BACKWARD, FFTW\_ESTIMATE) ;
/\* initialize the state \*/
for (y=0, ip=state; y> SHIFT ;
if (s)
\*ip = (t == 2 || t == 3) ;
else
\*ip = (t == 3) ;
}
}
/\* that's it! dump the frame! \*/
char fname[80] ;
sprintf(fname, "frame.%04d.pgm", g) ;
FILE \*fp = fopen(fname, "wb") ;
fprintf(fp, "P5\n%d %d\n%d\n", SIZE, SIZE, 255) ;
for (y=0, ip=state; y
```
Для сборки нужна библиотека [FFTW](http://www.fftw.org/). Ключи для сборки в gcc:
> gcc life.cpp -lfftw3 -lm -lstdc++
в Visual Studio нужны изменения в работе с комплексными числами.
**Изображения во время выполнения алгоритма:**
Исходная матрица фильтра (начало координат — левый верхний угол, поле «закольцовано»):
Действительная часть фильтра после прямого БПФ:
Исходное поле — 1 глайдер:
БПФ исходного поля, действительная и мнимая части:
 
После умножения на матрицу фильтра:
 
После обратного БПФ — получаем суммы:
Результат вполне ожидаемый:
«Закольцовывание» поля получается автоматически из-за БПФ.
Плюшки БПФ
==========
* Вы можете суммировать любое количество элементов с любыми коэффициентами — а время работы **остается фиксированным**, N2logN. Т.е. если для классической жизни — обычные алгоритмы на заполненных полях все еще достаточно быстрые, то с увеличением площади/объема суммирования — они становятся все медленнее, а скорость работы БПФ остается фиксированной.
* БПФ — уже написан, отлажен и оптимизирован идеально — с использованием всех возможностей процессора: sse, sse2, avx, altivec и neon.
* Вы легко можете использовать все процессоры и видеокарты взяв готовые многопроцессорные и CUDA/OpenCL реализации БПФ. Опять же, об оптимизации БПФ вам заботится не нужно. FFTW кстати поддерживает многопроцессорное выполнение (--enable-openmp во время сборки), чем больше поле — тем меньше потери на синхронизацию.
* Тот же подход применим и к 3D пространству.
Сравниваем скорость работы с «наивной» реализацией
==================================================
FFTW собран в режиме одинарной точности (--enable-float, дает прирост скорости примерно в 1.5 раза). Процессор — Core2Duo E8600. gcc 4.7.2 -O3
**Исходный текст наивной реализации**
```
for (int i=8; i<1000; i++)
{
delta[i][0] = (lrand48() % 21)-10;
delta[i][1] = (lrand48() % 21)-10;
}
#define NUMDELTA 18
for(int frame=0;frame<10;frame++)
{
double start = ticks();
for (y=0; y3 || sum<2)?0:1;else
array[1-readpage][y][x] = (sum==3)?1:0;
}
readpage = 1-readpage;
printf("NaiveDelta: %10.10f\n", ticks()-start);
}
```
| | |
| --- | --- |
| Конфигурация теста | При каком количестве суммируемых клеток скорость FFT и наивной реализации равна |
| 1 ядро, 512x512 | 29 |
| 2 ядра, 512x512 | 18 |
| 1 ядро, 4096x4096 | 88 |
| 2 ядра, 4096x4096 | 65 |
Как видим, хоть асимптотика и против FFT — но если суммировать нужно сотни и тысячи клеток — то FFT выиграет.
**Update:**
Как оказалось, FFTW при указании флага FFTW\_ESTIMATE использует далеко не оптимальные планы вычисления FFT. При указании FFTW\_MEASURE — скорость сильно выросла, и ситуация выглядит уже радостнее (при суммировании менее 18 клеток — наивная реализация резко становится в 3 раза быстрее, потому тут все упирается в 18):
| | |
| --- | --- |
| Конфигурация теста | При каком количестве суммируемых клеток скорость FFT и наивной реализации равна |
| 1 ядро, 512x512 | 18 |
| 2 ядра, 512x512 | 18 |
| 1 ядро, 4096x4096 | 28 |
| 2 ядра, 4096x4096 | 19 |
Чтобы ни говорили — математика в программировании иногда может пригодиться в самых неожиданных местах.
И да пребудет с вами сила FFT! | https://habr.com/ru/post/180135/ | null | ru | null |