Параллельная реализация логических нейронных сетей

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

Int *dev_ptr = 0;

cudaMalloc((void**)&dev_ptr, sizeof(int)*N), где N - количество используемых значений.

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

«cudaMemcpy(dev_ptr, input , N * sizeof(int), cudaMemcpyHostToDevice);» , где

dev_ptr - наш указатель,

input - передаваемое значение,

N * sizeof(int), - размер в байтах,

cudaMemcpyHostToDevice - направление передачи данных, HostToDevice означает передачу с центрального процессора(Host) на процессор графической карты(Device).

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

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

«addKernel<<<grid, threads>>>(dev_ptr, dev_array);», где

addKernel - имя функции,

grid - количество используемых блоков памяти, целое число

threads - количество нитей в каждом блоке, целое число

dev_array - массив, в котором записана структура сети и все введённые изначально функции.

Запись вида <<<A,B>>>( dev_ptr, dev_array) является указанием компилятору выполнить функцию на графической карте, а не на центральном процессоре. В скобках указываются передаваемые параметры.

Сама функция, выполняемая на графической карте имеет следующий прототип:

__global__ void addKernel(int *dev_ptr, int *dev_array);

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

Int i_x = blockIdx.x + threadIdx.x;

Поскольку используемые нами массивы являются двумерными, необходимо ещё одно обозначение:

Int i_y = blockIdx.y + threadIdx.y;

Так мы получаем уникальные номера для каждого из используемых значений а следовательно можем параллельно вычислить все функции.



Заключение

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

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

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

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

Технология параллельных вычислений на графической карте CUDA, выпущенная компанией Nvidia в 2007 году, на сегодняшний день является одной из передовых технологий вычислений на графической карте. Использование параллелизма во многих сферах позволяет добиваться поставленных целей в разы быстрее, нежели при использовании последовательных вычислений на центральном процессоре.

Использование технологии CUDA в данной работе позволило реализовать алгоритмы работы логической нейронной сети. Благодаря специальной структуре памяти, при использовании технологии CUDA возможно одновременное вычисление до нескольких тысяч процессов. Так, перебор всех входных значений переменных может быть изменён с последовательного на параллельный, благодаря чему количество операций будет ограничено только количеством ядер в графической карте. Таким образом, применение технологии CUDA позволяет добиться максимальной эффективности работы от реализованной программы.

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

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



Список литературы

1 McCulloch W.S., Pitts W. A logical calculus of the immanent in nervous activity// Bulletin of mathematical biophysics. 1943. V5.

2 Nordstrom T. Designing parallel computers for self-organizing maps. Forth Swedish Workshop on Computer System Architecture. 1992.

3 Барский А.Б. Логические нейронные сети. НОУ «ИНТУИТ», 2016.

4 Хайкин С. Нейронные сети: полный курс, 2-е изд., испр. - М.: Издательский дом «Вильямс», 2006. - 1104 с.

5 Чень Ч., Ли Р. Математическая логика и автоматическое доказательство теорем. М.: Наука. Главная редакция физико-математической литературы, 1983.

6 Shapiro E.Y. Concurrent prolog: Collected papers. Cambridge. MIT Press, 1987

7 Боголюбов Д.П., Чанкин А.А., Стемиковская К.В. Реализация алгоритма обучения самоорганизующихся карт Кохонена на графических процессорах // Промышленные АСУ и контроллеры. 2012. № 10. С. 30-35.

8 Официальный сайт компании Nvidia посвящённый технологии CUDA.

URL: https://developer.nvidia.com/cuda-zone (дата обращения 20.01.2016)

9 Сандерс Дж., Кэндрот Э. Технология CUDA в примерах: введение в программирование графических процессоров: Пер. с англ. - М.:ДМК Пресс, 2011.



Приложение 1

Исходный код программы на c++.

Файл main.cpp

#include <iostream>

#include <string>

#include <vector> // подключаем заголовок списка

#include <iterator>

#include <stdlib.h>

#include <math.h>

#include "kernel.cu"

using namespace std;

int main()

{

char B = '0';

int e = 0;

string s;

while (e == 0)

{

vector<string> VS;

std::cout << "Enter number : " << '\n';

std::cin >> B;

std::cout << '\n';

if ((B == 'S') || (B == 's'))

{

while (s != ".")

{

std::cin >> s;

VS.push_back(s);

}

s = '0';

VS.pop_back();

}

if ((B == 'E') || (B == 'e'))

{

e++;

}

int PC = 0, NC = 0;

int ind[27];

string tot_elms, neg_elms;

for (unsigned int i = 65; i< 91; i++)

{

ind[i - 65] = i;

//cout<<ind[i-65]<<", "<<(char)i<<'\n';

}

if (VS.begin() != VS.end())

{

copy(VS.begin(), VS.end(), ostream_iterator<string>(cout, ","));

std::cout << '\n';

for (unsigned int i = 0; i< VS.size(); i++)

{

for (unsigned int j = 0; j< VS[i].size(); j++)

{

if (((int)VS[i][j] >= 65) && ((int)VS[i][j]<91))

{

if (j > 0) {

if (VS[i][j-1] == '!')

{

neg_elms = neg_elms + VS[i][j];

NC++;

}

}

for (unsigned int DN = 0; DN< 26; DN++)

{

if (((int)VS[i][j] == ind[DN]) && (int(VS[i][j]!= 0)))

{

tot_elms = tot_elms + VS[i][j];

ind[DN] = 0;

PC++;

}

}

}

}

}

//cout<<PC<<" <+> "<<tot_elms<<'\n'<<NC<<" <+>"<<neg_elms<<'\n';//получил количество входных нейронов, множество неотр элеентов и тех, для которых необходимо отрицание

//std::cout << '\n'<<neg_elms.length() << "==== " << tot_elms.length()<< " === " << VS.size() + 2 << '\n';

int TL = tot_elms.length();

int LS = VS.size() + 2;

int **array = new int*[TL];

for (int i = 0; i < TL; i++) { array[i] = new int[LS];}

for (unsigned int i = 0; i< tot_elms.length(); i++)

{

for (unsigned int j = 0; j< VS.size() + 2; j++)

{

array[i][j] = 0;

}

}

//вспомогательная матрица для построения структуры работы

for (int i = 0; i<tot_elms.length(); i++)

{

for (int j = 0; j<neg_elms.length(); j++)

{

if (tot_elms[i] == neg_elms[j])

{

array[i][1] = 1;

}

}

}

//столбец, отвечающий за наличие обратных эл-тов

int *NOITN = new int [LS];//number of inputs to neuron;

for (unsigned int i = 0; i < LS; i++)

{

NOITN[i] = 0;

}

for (unsigned int i = 0; i< VS.size(); i++)

{

for (unsigned int j = 0; j< VS[i].size(); j++)

{

for (unsigned int k = 0; k < tot_elms.length(); k++)

{

if (j == 0) {

if (tot_elms[k] == VS[i][j])

{

array[k][i + 2] = 1; NOITN[i + 2]++;

}

}

if (j > 0) {

if ((tot_elms[k] == VS[i][j]) && (VS[i][j - 1]!= '!'))

{

array[k][i + 2] = 1; NOITN[i + 2]++;

}

if ((tot_elms[k] == VS[i][j]) && (VS[i][j - 1]== '!'))

{

array[k][i + 2] = -1; NOITN[i + 2]++;

}

}

}

}

}

cout << '\n';

//анализ всех входных формул

int NumOfInp = tot_elms.length();

int sr = pow(2, TL);

int tl2 = TL;

int **input = new int*[tl2];

for (int i = 0; i < tl2; i++) { input[i] = new int[sr]; }

for (unsigned int i = 0; i < TL; i++)

{

for (unsigned int j = 0; j < sr; j++)

{

input[i][j] = 0;

}

}

cout << '\n';

for (unsigned int i = 0; i<TL; i++)

{

for (unsigned int j = 0; j<sr; j++)

{

input[i][j] = (j >> i) & 0xF1; cout << input[i][j];

}cout << '\n';

}

cout << '\n';

//cоздание двоичной таблицы входных данных

double *ResultArray = new double[VS.size() + 2];

double *h = new double[VS.size() + 2];

double *W= new double[VS.size() + 2];

for (unsigned int i = 0; i<VS.size() + 2; i++)

{

ResultArray[i] = 0;

W[i] = 1;

h[i] = 0;

}

cudapeqi(array,input,ResultArray, TL,LS, sr,NOITN);

//cout << "--------------" << '\n';

copy(VS.begin(), VS.end(), ostream_iterator<string>(cout, ","));

std::cout << '\n';

VS.clear();

}

}

return 0;

}



Приложение 2

Исходный код программы на c++.

Файл “kernel.cu”

#include <iostream>

#include "cuda_runtime_api.h"

#include "cuda_runtime.h"

#include "cuda.h"

#include "device_launch_parameters.h"

#include <time.h>

using namespace std;

__global__ void add(double * ResultArray,int **array, int **input, int TL, int LS, int sr, int*NOITN,int TR) {

TR = 0;

int i = threadIdx.x; ResultArray[i] = 0;

int j = threadIdx.y;

if (array[i][j+2] == 1) { ResultArray[j+2] = ResultArray[j+2] + input[i][j]; NOITN[j+2]++; }

if (array[i][j+2] == -1) { ResultArray[j+2] = ResultArray[j+2] + ((input[i][j] + 1) % 2); NOITN[j+2]++;

}

for (unsigned int j = 2; j < LS; j++)

{

if ((ResultArray[j] == 0) || (ResultArray[LS - 1] == 0)) {

break;

}

else {ResultArray[j] = 0; TR = 1;

}

}

}

#define N 48

int cudapeqi(int **array,int **input,double *ResultArray, int TL,int LS,int sr,int *NOITN) {

cudaEvent_t start, stop;

float gpuTime = 0;

cudaEventCreate(&start);

cudaEventCreate(&stop);

cudaEventRecord(start, 0);

int TR=0;

int** dev_array;

int** dev_input;

double *dev_res;

int* dev_noi;

cudaMalloc((void **)&dev_array, sizeof(int)*TL*LS);

cudaMalloc((void **)&dev_input, sizeof(int)*TL*sr);

cudaMalloc((void **)&dev_res, sizeof(int)*LS);

cudaMalloc((void **)&dev_noi, sizeof(int)*LS);

cudaMemcpy(dev_array, &array, sizeof(int)*TL*LS, cudaMemcpyHostToDevice);

cudaMemcpy(dev_input, &input, sizeof(int)*TL*sr, cudaMemcpyHostToDevice);

cudaMemcpy(dev_res, &ResultArray, sizeof(int)*LS, cudaMemcpyHostToDevice);

cudaMemcpy(dev_noi, &NOITN, sizeof(int)*LS, cudaMemcpyHostToDevice);

cudaEventRecord(start, 0);

add << <TL, LS >> > (dev_res,dev_array, dev_input, TL, LS, sr, dev_noi,TR);

cudaEventRecord(stop, 0);

cudaEventSynchronize(stop);

cudaEventElapsedTime(&gpuTime, start, stop);

cout << "time = " << gpuTime << '\n';

cudaMemcpy(ResultArray, dev_res, sizeof(int)*LS, cudaMemcpyDeviceToHost);

if (TR != 0) { cout << "true"; }

else {

cout << "false";

}

system("pause");

cudaFree(dev_array);

cudaFree(dev_input);

cudaFree(dev_res);

cudaFree(dev_noi);

cudaEventDestroy(start);

cudaEventDestroy(stop);

return 0;

}

Размещено на Allbest.ru