HopfieldNetwork Class Reference

Hopfield Algorithm with number based inputs. More...

#include <HopfieldNetwork.h>

Public Member Functions
	HopfieldNetwork (float omega=0.5, float T=3.1, float Tmin=0.1, float cmax=0.01)
	Constructor taking parameters for the algorithm.
unsigned short	doHopfield (std::vector< OverlapResolverNodeInfo > &overlapResolverNodeInfos, unsigned short nIterations=20)
	Performance of the actual algorithm.

Private Attributes
float	m_omega
	tuning parameter of the hopfield network
float	m_T
	start temperature of annealing
float	m_Tmin
	minimal temperature allowed
float	m_cmax
	maximal change of weights between iterations

Detailed Description

Hopfield Algorithm with number based inputs.

This class encapsulates the actual algorithm with pure number inputs (instead of objects of TrackCandidates or whatever). The reason for this is mainly better testability and potentially as well reusability. The development of this class started as a copy from Jakob's implementation for the VXDTF2.

Relevant resources: [1] R. Frühwirth, "Selection of optimal subsets of tracks with a feedback neural network", Comput. Phys. Commun., vol. 78, pp. 23–28, 1993.

Definition at line 33 of file HopfieldNetwork.h.

Constructor & Destructor Documentation

HopfieldNetwork()

HopfieldNetwork ( float  omega = 0.5, float  T = 3.1, float  Tmin = 0.1, float  cmax = 0.01  )

inline

Constructor taking parameters for the algorithm.

Parameters

omega	Should be between 0 and 1; small values lead to large number of nodes, large ones to large sums of quality indicators.
T	Temperature for annealing.
Tmin	Minimal reached temperature in the annealing scheme.
cmax	Maximum change of weights between iterations, so we accept the network as converged.

Definition at line 42 of file HopfieldNetwork.h.

                                                                                          :
      m_omega(omega), m_T(T), m_Tmin(Tmin), m_cmax(cmax)
    {}

Member Function Documentation

doHopfield()

unsigned short doHopfield	(	std::vector< OverlapResolverNodeInfo > &	overlapResolverNodeInfos,
		unsigned short	nIterations = 20
	)

Performance of the actual algorithm.

HINT FOR SPEED OPTIMIZATION: A lot of time is spend for checking the Logger, if you don't have LOG_NO_B2DEBUG defined. If you have done that, a lot of time is taken by the tanh function and drawing random numbers.

Currently this algorithm can only be used once for each instance, as the algorithm parameter variables are changed during the performance.

See also

OverlapResolverNodeInfo

Definition at line 20 of file HopfieldNetwork.cc.

{
  //Start value for neurons if they are compatible.
  //Each compatible connection activates a node with this value.
  //As the sum of all the activations shall be less than one, we divide the
  //activiation by the total number of Nodes.
  //Incompatible Nodes get later minus one, which counteracts all activation,
  //if the incompatible Node is active.
  if (overlapResolverNodeInfos.size() < 2) {
    B2DEBUG(20, "No reason to doHopfield with less than 2 nodes!");
    return 0;
  }
 
  const float compatibilityValue = (1.0 - m_omega) / static_cast<float>(overlapResolverNodeInfos.size() - 1);
 
  const size_t overlapSize = overlapResolverNodeInfos.size();
 
  //Weight matrix; knows compatibility between each possible pair of Nodes
  Eigen::MatrixXd W(overlapSize, overlapSize);
  //A): Set all elements to compatible:
  W.fill(compatibilityValue);
 
  //B): Inform weight matrix elements of incompatible neurons:
  for (const auto& aTC : overlapResolverNodeInfos) {
    for (unsigned int overlapIndex : aTC.overlaps) {
      W(aTC.trackIndex, overlapIndex) = -1.0;
    }
  }
 
 
  // Neuron values
  Eigen::VectorXd x(overlapSize);
  // randomize neuron values for first iteration:
  for (unsigned int i = 0; i < overlapSize; i++) {
    x(i) = gRandom->Uniform(1.0); // WARNING: original does Un(0;0.1) not Un(0;1)!
  }
 
  //Store for results from last round:
  Eigen::VectorXd xOld(overlapSize);
 
  //Order of execution for neuron values:
  std::vector<unsigned short> sequenceVector(overlapSize);
  //iota fills the vector with 0, 1, 2, ... , (size-1)
  std::iota(sequenceVector.begin(), sequenceVector.end(), 0);
 
  //The following block will be evaluated to empty, if LOG_NO_B2DEBUG is defined:
  B2DEBUG(29, "sequenceVector with length " << sequenceVector.size());
  B2DEBUG(29, "Entries are from begin to end:");
  for (auto&& entry : sequenceVector) {
    B2DEBUG(29, std::to_string(entry) + ", ");
  }
 
  //Store all values of c for protocolling:
  std::vector<float> cValues(nIterations);
  //Store for maximum change of weights between iterations.
  float c = 1.0;
 
  //Iterate until change in weights is small:
  unsigned iIterations = 0;
 
  float T = m_T;
 
 
  while (c > m_cmax) {
    std::shuffle(sequenceVector.begin(), sequenceVector.end(), TRandomWrapper());
 
    xOld = x;
 
    for (unsigned int i : sequenceVector) {
      float aTempVal = W.row(i).dot(x);
      float act = aTempVal + m_omega * overlapResolverNodeInfos[i].qualityIndicator;
      x(i) = 0.5 * (1. + tanh(act / T));
    }
 
    T = 0.5 * (T + m_Tmin);
 
    //Determine maximum change in weights:
    c = (x - xOld).cwiseAbs().maxCoeff();
    B2DEBUG(21, "c value is " << c << " at iteration " << iIterations);
    cValues.at(iIterations) = c;
 
    if (iIterations + 1 == nIterations) {
      B2INFO("Hopfield reached maximum number of iterations without convergence. cValues are:");
      for (auto&& entry : cValues) {
        B2INFO(std::to_string(entry));
      }
      break;
    }
    iIterations++;
  }
 
  //Copy Node values into the activity state of the OverlapResolverNodeInfo objects:
  for (unsigned int i = 0; i < overlapSize; i++) {
    overlapResolverNodeInfos[i].activityState = x(i);
  }
 
  return iIterations;
}

Member Data Documentation

m_cmax

float m_cmax

private

maximal change of weights between iterations

Definition at line 63 of file HopfieldNetwork.h.

m_omega

float m_omega

private

tuning parameter of the hopfield network

Definition at line 60 of file HopfieldNetwork.h.

m_T

float m_T

private

start temperature of annealing

Definition at line 61 of file HopfieldNetwork.h.

m_Tmin

float m_Tmin

private

minimal temperature allowed

Definition at line 62 of file HopfieldNetwork.h.

---

The documentation for this class was generated from the following files:

• tracking/trackFindingVXD/trackSetEvaluator/include/HopfieldNetwork.h
• tracking/trackFindingVXD/trackSetEvaluator/src/HopfieldNetwork.cc