hfneuron.cpp

人工神经网络的源码编程

/*
 * public/ann/hopfield/hfneuron.cpp
 * 2004-05-28 by ShanLanshan
 */
#include <stdio.h>
#include <assert.h>
#include "public/ann/hopfield/hfneuron.h"

namespace ann {

	//////////////////////////////////////////////////////////////
	//	class VectorElementValue
	//////////////////////////////////////////////////////////////
	
	VectorElementValue::VectorElementValue(): m_vec(NULL), m_off(0) {}

	VectorElementValue::VectorElementValue(IAnnVector *vec, ann_int off)
	{
		VectorElementValue();
		set_vector_element(vec, off);
	}

	bool VectorElementValue::set_vector_element(IAnnVector *vec, ann_int off)
	{
		if (m_vec == NULL)
			return false;

		if (m_off < 0)
			return false;

		if (m_off >= m_vec->get_size())
			return false;

		m_vec = vec;
		m_off = off;

		return true;
	}

	ann_float VectorElementValue::get_value()
	{
		assert(m_vec != NULL);
		assert(m_off >= 0);
		assert(m_off < m_vec->get_size());

		return m_vec->get_element(m_off);
	}

	void VectorElementValue::set_value(ann_float v)
	{
		assert(m_vec != NULL);
		assert(m_off >= 0);
		assert(m_off < m_vec->get_size());

		return m_vec->set_element(m_off, v);
	}

	//////////////////////////////////////////////////////////////
	//	class NeuronProbe
	//////////////////////////////////////////////////////////////
	
	NeuronProbe::NeuronProbe(): m_value(NULL), m_flag(0) {}

	NeuronProbe::~NeuronProbe()
	{
		if (m_value != NULL) {
			delete m_value;
			m_value = NULL;
		}
	}


	//////////////////////////////////////////////////////////////
	//	class HFNeuron
	//////////////////////////////////////////////////////////////
	HFNeuron::HFNeuron():
		//m_old_value(ANN_FLOAT_ZERO),
		m_adjust(ANN_FLOAT_ZERO) { }
	HFNeuron::~HFNeuron(){}
	void HFNeuron::respond()
	{
		Neuron::respond();
		m_stimulation += m_adjust;
		m_respond = m_stimulation;
	}

	//////////////////////////////////////////////////////////////
	//	class HFSimpleGroup
	//////////////////////////////////////////////////////////////
	HFSimpleGroup::HFSimpleGroup():
		m_forget_power(true),
		m_learn_rate(0.01),
		m_regular_input_power(false),
		m_learn_adjust(true) {}
	HFSimpleGroup::HFSimpleGroup(int size)
	{ 
		HFSimpleGroup();
		init(size); 
	}
	HFSimpleGroup::~HFSimpleGroup(){}
	bool HFSimpleGroup::init(int size)
	{
		NeuronObj *obj;
		HFNeuron *hfn;

		for (int i=0; i<size; ++i) {
			hfn = new HFNeuron;
			obj = static_cast<NeuronObj*> (hfn);
			assert(obj != NULL);
			this->add(obj, 0);
		}

		return true;
	}

	bool HFSimpleGroup::mutual_conn()
	{
		Neuron *n, *n2;
		NeuronObj *obj, *obj2;

		NeuronGroup::iterator i, j;
		for (obj=move_first(&i); not_end(&i); obj=move_next(&i)) {
			assert(obj != NULL);
			n = dynamic_cast<Neuron*> (obj);
			assert(n != NULL);
			for (obj2=move_first(); not_end(); obj2=move_next()) {
				n2 = dynamic_cast<Neuron*> (obj2);
				assert(n2 != NULL);
				n->accept_conn(n2);
			}
		}
		return true;
	}

	void HFSimpleGroup::learn()
	{
		Neuron *n, *n2;
		NeuronObj *obj;
		Synapse *s;
		HFNeuron *hfn;
		ann_float upv;
		ann_float r = m_learn_rate;
		bool regular = m_regular_input_power, forget = m_forget_power, adjust = m_learn_adjust;

		for (obj=move_first(); not_end(); obj=move_next()) {
			assert(obj != NULL);
			n = dynamic_cast<Neuron*> (obj);
			assert(n != NULL);
			for (
				list<Synapse*>::iterator i = n->m_synapse_list.begin();
				i != n->m_synapse_list.end();
				++i
			) {
				s = (*i);
				assert(s != NULL);
				n2 = s->get_input_neuron();
				assert(n2 != NULL);
				upv = n->get_output() * n2->get_output();
				s->update_power(upv, r, forget);
			}

			if (regular)
				n->regular_input_power();

			hfn = dynamic_cast<HFNeuron*> (n);
			if (adjust) {
				hfn->set_adjust(hfn->get_adjust() * (1 - r));
				hfn->set_adjust(hfn->get_adjust() + n->get_output() * r);
			}
		}
	}


	void HFSimpleGroup::restart()
	{
	}

} // namespace ann