Генетический алгоритм

Автор работы: Пользователь скрыл имя, 31 Декабря 2010 в 00:58, курсовая работа

Краткое описание

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

Содержание работы

ВВЕДЕНИЕ 5
1 МОДЕЛИРОВАНИЕ РАБОТЫ НЕЙРОННОЙ СЕТИ 6
2 АЛГОРИТМ ОБРАТНОГО РАСПРОСТРОНЕНИЯ ОШИБКИ 10
3 ГЕНЕТИЧЕСКИЙ АЛГОРИТМ 15
4 ЭФФЕКТИВНОСТЬ ГЕНЕТИЧЕСКИХ АЛГОРИТМОВ 22
4.1 Показатели эффективности генетических алгоритмов 22
4.2 Скорость работы генетических алгоритмов 22
4.3 Устойчивость работы генетических алгоритмов 24
4.4 Направления развития генетических алгоритмов 27
ЗАКЛЮЧЕНИЕ 30
СПИСОК ЛИТЕРАТУРЫ 31
ПРИЛОЖЕНИЕ 32

Скачать целиком (108.88 Кб) Сколько стоит заказать работу?
Содержимое работы - 1 файл

Курсовая_Таня.docx

— 115.30 Кб (Скачать файл)

                  for (int j = 0; j < W[rnd1].Length; j++)

                  {

                        temp[j] = W[rnd1][j];

                  }

                  for (int i = 0; i < W.Length; i++)

                  {

                        temp2[i] = W[i][rnd2];

                        W[i][rnd2] = temp[i];

                  }

                  for (int j = 0; j < W[rnd1].Length; j++)

                  {

                        W[rnd1][j] = temp2[j];

                  }

                  if (s > 500)

                        s = 0;

                  else

                        s++;

            }

            static double[][][] Screshivanie(double[][] W1, double[][] W2)//оператор скрещивания, возвращает двух потомков

            {

                  Random rnd = new Random(s);

                  int rnd1 = rnd.Next(0,5); 

                  double[] temp = new double[W1[0].Length];

                  double[][][] resultW = new double[2][][];//для двух потомков

                  double[][][] resultW_temp = new double[2][][];

                  resultW[0] = new double[W1.Length][];

                  resultW[1] = new double[W1.Length][];

                  resultW_temp[0] = new double[W1.Length][];

                  resultW_temp[1] = new double[W1.Length][];

                  int rnd2 = rnd.Next(0, 5);

                  for (int i = 0; i < W1.Length; i++)

                  { 

                        resultW_temp[0][i] = new double[W1[i].Length];

                        resultW_temp[1][i] = new double[W1[i].Length];

                        resultW[0][i] = new double[W1[i].Length];

                        resultW[1][i] = new double[W1[i].Length];

                        for (int j = 0; j < W1[i].Length; j++ )

                        {

                              resultW_temp[0][i][j] = W1[i][j];

                              resultW_temp[1][i][j] = W2[i][j];

                              resultW[0][i][j] = W1[i][j];

                              resultW[1][i][j] = W2[i][j];

                        }

                  } 

                  //меяет одну случайных  строки между двумя массивами 

                  //проверяем не  равны ли строки у родителей

                  bool[] str1 = new bool[resultW_temp[0].Length];

                  bool[] str2 = new bool[resultW_temp[0].Length];

                  for (int i = 0; i < resultW_temp[0].Length; i++)

                  {

                        str1[i] = true;

                        str2[i] = true;

                  }

                  for (int i = 0; i < resultW_temp[0].Length; i++)

                  {

                        for (int j = 0; j < resultW_temp[0][i].Length; j++)

                        {

                              if (resultW[0][i][j] != resultW_temp[1][i][j])

                              {

                                    str1[i] = false;

                                    break;

                              }

                        }

                  }

                  for (int i = 0; i < resultW_temp.Length; i++)

                  {

                        for (int j = 0; j < resultW_temp[0].Length; j++)

                        {

                              if (resultW[0][i][j] != resultW_temp[1][i][j])

                              {

                                    str2[i] = false;

                                    break;

                              }

                        }

                  }

                  if (!str1[rnd1])//если случайные  строки не равны

                  {

                        for (int j = 0; j < resultW_temp[0].Length; j++)

                        {

                              resultW[0][rnd1][j] = resultW_temp[1][rnd1][j];

                              resultW[1][rnd1][j] = resultW_temp[0][rnd1][j];

                        }

                  }

                  else

                  {

                        //выбираем первую  не равную пару строк

                        for (int i = 0; i < resultW_temp.Length; i++)

                        {

                              if (!str1[i])

                              {

                                    for (int j = 0; j < resultW_temp[0].Length; j++)

                                    {

                                          resultW[0][i][j] = resultW_temp[1][i][j];

                                          resultW[1][i][j] = resultW_temp[0][i][j];

                                    }

                                    break;

                              }

                              else//если таких  пар не найдено то меняем  случайные строки

                              {

                                    for (int j = 0; j < resultW_temp[0].Length; j++)

                                    {

                                          resultW[0][rnd1][j] = rnd.NextDouble() * 0.1;

                                          resultW[1][rnd1][j] = rnd.NextDouble() * 0.1;

                                    }

                              }

                        }

                  }

                  if (s > 500)

                        s = 0;

                  else

                        s++;

                  return resultW;

            }

            static SandY neuro(double[][] X, double[][] W)//типа нейрон

            {

                  SandY result;

                  double alfa = 1;//коэфицент сигмоидности

                  result.S = 0;//результирующая сумма

                  for (int i = 0; i < X.Length; i++)

                  {

                        for (int j = 0; j < X[i].Length; j++)

                        {

                              result.S += X[i][j] * W[i][j];//комбинаторим

                        }

                  }

                  result.Y = 1 / (1 + Math.Exp(alfa * result.S));//функция активизации

                  return result;

            }

            static void Main(string[] args)

            {

                  double[][] input_x0 = new double[5][];

                  double[][] input_x1 = new double[5][];

                  double[][][] weight = new double[2][][];//веса для двух нейрон 

                  for (int i = 0; i < 5; i++)

                  {

                        input_x0[i] = new double[5];

                        input_x1[i] = new double[5];

                  }

                  int seed = 0;

                  for (int n = 0; n < 2; n++)//заполняем  веса случайными значениями от 0,0 до 1,0

                  {

                        weight[n] = new double[5][];

                        for (int i = 0; i < 5; i++)

                        {

                              weight[n][i] = new double[5];

                              for (int j = 0; j < 5; j++)

                              {

                                    weight[n][i][j] = new Random(seed).NextDouble()*0.1;

                                    seed++;

                              }

                        }

                  }

                        //тестовая матрица  для 0

                  input_x0[0][0] = 0;

                  input_x0[0][1] = 1;

                  input_x0[0][2] = 1;

                  input_x0[0][3] = 1;

                  input_x0[0][4] = 0; 

                  input_x0[1][0] = 1;

                  input_x0[1][1] = 0;

                  input_x0[1][2] = 0;

                  input_x0[1][3] = 0;

                  input_x0[1][4] = 1; 

                  input_x0[2][0] = 1;

                  input_x0[2][1] = 0;

                  input_x0[2][2] = 0;

                  input_x0[2][3] = 0;

                  input_x0[2][4] = 1; 

                  input_x0[3][0] = 1;

                  input_x0[3][1] = 0;

                  input_x0[3][2] = 0;

                  input_x0[3][3] = 0;

                  input_x0[3][4] = 1; 

Информация о работе Генетический алгоритм