A simple single unit adaptive network:

The network has 2 inputs, and one output. All are binary. The output
is

1 if W0 *I0 + W1 * I1+ Wb > 0

0 if W0 *I0 + W1 * I1+ Wb <= 0

We want it to learn simple OR: output a 1 if either I0 or I1 is 1.

For Solving this problem i have made this-

#include <iostream>
 
struct Newron
{
   int value;
   int weight;
};
 
int main()
{
  Newron input_one, input_two, output;
  int bias = 0;
 
  input_one.weight = 1;
  input_two.weight = 1;
 
  std::cin >> input_one.value;
  std::cin >> input_two.value;
 
  output.value = (input_one.value * input_one.weight) + (input_two.value * input_two.weight) + bias;
 
  if(output.value > 0)
    std::cout << 1 << std::endl;
  else
    std::cout << 0 << std::endl;
 
  return 0;
}

Is it the right way?

If not then how it can be done?

Thanks for your help in advance.

I can't comment, but I'll suggest you a) DON'T MAKE YOUR TITLE LOOK LIKE IT'S SHOUTING, and b) use [ code ][ /code ] (without spaces) tages for code to help with formatting/highlighting.

Good luck!

I can't comment, but I'll suggest you a) DON'T MAKE YOUR TITLE LOOK LIKE IT'S SHOUTING, and b) use [ code ][ /code ] (without spaces) tages for code to help with formatting/highlighting.

Good luck!

Sorry for the title :D And i changed the code formatting, but couldn't be able to change the title.

Hello

This seems to be a good start for me

In fact you are precisely describing (wanting ?) Perceptron model

This is pseudo-code :

class Neuron
{
	float [] inputs; // (with : true is 1.0f, false is 0.0f)
	float [] weights; //idem

	Constructor(integer nbInputs)
	{
		inputs=new array [nbInputs +1] (+1 is for including the bias). Or getting a reference on an external array.
		weights=new array [nbInputs +1]
		
		fill the weights array with float random values between -1 and 1
		set 1.0f in the position corresponding to the bias in the inputs array(typically, first or last position)
	}
	
	float computeOutput()
	{
		sum=dotProduct(inputs,weights);
		return sum>0.0f;
	}

	void learn(float desiredOutput,float learningRate) // adaptation of the weights
	{
		float output=computeOutput();
		float deltaOutput=desiredOutput-output; (so -1.0f or 0.0f or 1.0f)
		
		for each position in the arrays
		{
			weights[i]+=learningRate*inputs[i]*deltaOutput;
		}
	}

};

Hope it makes sense

for a OR, it should converge with : w1=lambda, w2=lambda, et wBias=0, lambda>0

Good luck

Thank you very much :D Most of the part is clear to me, but I didn't understood the learningRate argument in the learn() method. Do I have to adjust it so that the network can learn or adjust weight on its own?

Don't worry, your english is as awesome as your explanation :D I am getting a hold of this, but I need to experiment a lot before I can understand it clearly. But you answered my question and that's enough for starting experiment without any confusion.

Thanks a lot for your help :D

Thanks again for the help. You know what, I was going to ask you the same thing. I was looking for some other neural networks, then I came across Hopfield network and there is a step when we need to convert the boolean(1 and 0) to 1 and -1. Then I was thinking if this could be done with Perceptron too. And before I could ask, you answered it :)