Нейронная сеть с прямой связью с HyperGraphDB

Одним из очевидных применений графовых баз данных, таких как HyperGraphDB, является реализация искусственных нейронных сетей (NN). В этом посте я покажу одну такую ​​реализацию на основе практической и информативной книги Тоби Сегарана «Программирование коллективного интеллекта»., В главе 4 автор показывает, как можно использовать обратную связь с пользователем для улучшения ранжирования результатов поиска. Идея состоит в том, чтобы обучить нейронную сеть ранжированию возможных URL-адресов с учетом комбинации ключевых слов. Предполагается, что пользователи выполнят поиск, затем изучат список результатов (с их названиями, резюме, типом документа и т. Д.) И, наконец, выберу тот, который, скорее всего, будет содержать информацию, которую он ищет. Это действие щелчка обеспечивает обратную связь, необходимую для обучения нейронной сети. С обучением сеть все чаще будет ранжировать лучшие документы по комбинации ключевых слов. И не только это, но это даст довольно хорошие предположения для поисков, которые он никогда не видел прежде.

public class Neuron { ... }
public class Synapse extends HGPlainLink
{
 private double strength;
 public Synapse(HGHandle...args) { super(args); }
 public HGHandle getInput() { return getTargetAt(0); }
 public HGHandle getOutput() { return getTargetAt(1); }
 public getStrength() { return strength; }
 public setStrength(double strength) { this.strength = strength; }
}

Чтобы получить все входы нейрона:

List<synapse> inputs = hg.getAll(graph, hg.and(hg.type(Synapse.class),hg.orderedLink(hg.anyHandle(), neuronHandle)));
</synapse>

Это будет работать просто отлично. Когда приходит время активировать нейрон, мы перебираем вышеприведенный список и применяем любую формулу, которую выбрали для нашей модели. Но есть и лучший способ: каждый нейрон может быть просто связующим звеном между своими входными нейронами, и он может содержать сильные стороны всех синапсов в двойном []:

public class Neuron extends HGPlainLink
{
  private double [] weights;
 
  public Neuron(HGHandle...inputNeurons)
  {
      super(inputNeurons);
  }
 
  public double fire(Map input,...) { ... }
 
  // etc...
}

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

public class NeuronOutput extends HGPlainLink
{
  public NeuronOutput(HGHandle...args)
  {
      super(args);
  }
  public HGHandle getNeuron()
  {
      return getTargetAt(0);
  }
  public HGHandle getOutputAtom()
  {
      return getTargetAt(1);
  }
}

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

public class NeuralNet
{
  private HyperGraph graph;
  private ActivationFunction activationFunction = new TanhFun();
  Map inputLayer = null;
  Map hiddenLayer = null;
  Map outputLayer = null;
 
  private Map activateNextLayer(Map previousLayer, Map nextLayer)
  {
      for (Map.Entry in : previousLayer.entrySet())
      {
          Collection downstream = hg.getAll(graph,
                                            hg.and(hg.type(Neuron.class),
                                                   hg.incident(in.getKey())));
          for (Neuron n : downstream)
              if (!nextLayer.containsKey(n))
                  nextLayer.put(graph.getHandle(n),
                                n.fire(previousLayer, activationFunction));
      }
      return nextLayer;
  }
 
  public NeuralNet(HyperGraph graph)
  {
      this.graph = graph;
  }
 
  public Map getOutputLayer()
  {
      return outputLayer;
  }
 
  public void feedforward(ActivationMap inputs)
  {
      inputLayer = inputs;
      hiddenLayer = activateNextLayer(inputLayer, new ActivationMap(0.0));
      outputLayer = activateNextLayer(hiddenLayer, new ActivationMap(0.0));
  }
 
  public void train(Collection inputs, Collection outputs,
                    HGHandle selectedOutput)
  {
      Collection outputNeurons = updateNeuralStructure(inputs, outputs);
      ActivationMap inputMap = new ActivationMap(0.0);
      for (HGHandle in : inputs)
          inputMap.put(in, 1.0);
      selectedOutput = hg.findOne(graph,
                                  hg.apply(hg.targetAt(graph, 0),
                                           hg.and(hg.type(NeuronOutput.class),
                                                  hg.incident(selectedOutput))));
      Map outputMap = new HashMap();
      for (HGHandle h : outputNeurons)
          outputMap.put(h, 0.0);
      outputMap.put(selectedOutput, 1.0);
      feedforward(inputMap);
      backpropagate(outputMap);
  }
}

Метод
train использует набор входных атомов, набор выходных атомов и один выходной атом, который был выбран среди всех выходов. Он начинается с того, что все выходные атомы имеют соответствующий нейрон, который подключен к соответствующему скрытому нейрону для этой конкретной входной комбинации. Все это делается в вызове
updateNeuralStructure . Затем метод создает ActivationMap, представляющий ожидаемую активацию выходного уровня: 0 для всех выходов, кроме выбранного, который имеет активацию 1. Затем на входе выполняется сеть, чтобы произвести свой собственный результат для выходного слоя (сохраненный в переменная члена outputLayer). Наконец,
обратное распространениерегулирует синаптические силы на основе различий между ожидаемым и рассчитанным выходом. Здесь можно тривиально добавить версию
поезда, которая использует полную карту ожидаемого выходного значения.