Neural Network Basics Gaming Project in C++

Projects Inventory

3 weeks ago

Neural Network Code:

#include <iostream>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <ctime>

const double LEARNING_RATE = 0.1;
const int INPUT_SIZE = 2;
const int HIDDEN_SIZE = 2;
const int OUTPUT_SIZE = 1;
const int NUM_EPOCHS = 10000;

// Sigmoid activation function
double sigmoid(double x) {
    return 1.0 / (1.0 + std::exp(-x));
}

// Derivative of sigmoid function
double sigmoid_derivative(double x) {
    return x * (1.0 - x);
}

// Neural Network class
class NeuralNetwork {
public:
    NeuralNetwork() {
        std::srand(std::time(0));
        
        // Initialize weights for hidden layer and output layer
        for (int i = 0; i < INPUT_SIZE; ++i) {
            for (int j = 0; j < HIDDEN_SIZE; ++j) {
                hiddenWeights[i][j] = (std::rand() / double(RAND_MAX)) - 0.5;
            }
        }
        
        for (int j = 0; j < HIDDEN_SIZE; ++j) {
            for (int k = 0; k < OUTPUT_SIZE; ++k) {
                outputWeights[j][k] = (std::rand() / double(RAND_MAX)) - 0.5;
            }
        }
        
        // Initialize biases
        for (int j = 0; j < HIDDEN_SIZE; ++j) {
            hiddenBiases[j] = (std::rand() / double(RAND_MAX)) - 0.5;
        }
        
        for (int k = 0; k < OUTPUT_SIZE; ++k) {
            outputBiases[k] = (std::rand() / double(RAND_MAX)) - 0.5;
        }
    }

    // Forward pass
    std::vector<double> forward(const std::vector<double>& input) {
        // Compute hidden layer activations
        std::vector<double> hiddenLayer(HIDDEN_SIZE);
        for (int j = 0; j < HIDDEN_SIZE; ++j) {
            double sum = 0.0;
            for (int i = 0; i < INPUT_SIZE; ++i) {
                sum += input[i] * hiddenWeights[i][j];
            }
            sum += hiddenBiases[j];
            hiddenLayer[j] = sigmoid(sum);
        }
        
        // Compute output layer activations
        std::vector<double> outputLayer(OUTPUT_SIZE);
        for (int k = 0; k < OUTPUT_SIZE; ++k) {
            double sum = 0.0;
            for (int j = 0; j < HIDDEN_SIZE; ++j) {
                sum += hiddenLayer[j] * outputWeights[j][k];
            }
            sum += outputBiases[k];
            outputLayer[k] = sigmoid(sum);
        }
        
        return outputLayer;
    }

    // Backpropagation to update weights
    void train(const std::vector<std::vector<double>>& inputs, const std::vector<std::vector<double>>& targets) {
        for (int epoch = 0; epoch < NUM_EPOCHS; ++epoch) {
            for (size_t i = 0; i < inputs.size(); ++i) {
                // Forward pass
                std::vector<double> hiddenLayer(HIDDEN_SIZE);
                std::vector<double> outputLayer(OUTPUT_SIZE);

                // Compute hidden layer activations
                for (int j = 0; j < HIDDEN_SIZE; ++j) {
                    double sum = 0.0;
                    for (int k = 0; k < INPUT_SIZE; ++k) {
                        sum += inputs[i][k] * hiddenWeights[k][j];
                    }
                    sum += hiddenBiases[j];
                    hiddenLayer[j] = sigmoid(sum);
                }

                // Compute output layer activations
                for (int k = 0; k < OUTPUT_SIZE; ++k) {
                    double sum = 0.0;
                    for (int j = 0; j < HIDDEN_SIZE; ++j) {
                        sum += hiddenLayer[j] * outputWeights[j][k];
                    }
                    sum += outputBiases[k];
                    outputLayer[k] = sigmoid(sum);
                }

                // Backpropagation
                std::vector<double> outputErrors(OUTPUT_SIZE);
                for (int k = 0; k < OUTPUT_SIZE; ++k) {
                    outputErrors[k] = targets[i][k] - outputLayer[k];
                }

                std::vector<double> hiddenErrors(HIDDEN_SIZE);
                for (int j = 0; j < HIDDEN_SIZE; ++j) {
                    hiddenErrors[j] = 0.0;
                    for (int k = 0; k < OUTPUT_SIZE; ++k) {
                        hiddenErrors[j] += outputErrors[k] * outputWeights[j][k];
                    }
                }

                // Update weights and biases for output layer
                for (int k = 0; k < OUTPUT_SIZE; ++k) {
                    for (int j = 0; j < HIDDEN_SIZE; ++j) {
                        double delta = LEARNING_RATE * outputErrors[k] * sigmoid_derivative(outputLayer[k]) * hiddenLayer[j];
                        outputWeights[j][k] += delta;
                    }
                    outputBiases[k] += LEARNING_RATE * outputErrors[k] * sigmoid_derivative(outputLayer[k]);
                }

                // Update weights and biases for hidden layer
                for (int j = 0; j < HIDDEN_SIZE; ++j) {
                    for (int k = 0; k < INPUT_SIZE; ++k) {
                        double delta = LEARNING_RATE * hiddenErrors[j] * sigmoid_derivative(hiddenLayer[j]) * inputs[i][k];
                        hiddenWeights[k][j] += delta;
                    }
                    hiddenBiases[j] += LEARNING_RATE * hiddenErrors[j] * sigmoid_derivative(hiddenLayer[j]);
                }
            }
        }
    }

private:
    double hiddenWeights[INPUT_SIZE][HIDDEN_SIZE];
    double outputWeights[HIDDEN_SIZE][OUTPUT_SIZE];
    double hiddenBiases[HIDDEN_SIZE];
    double outputBiases[OUTPUT_SIZE];
};

int main() {
    // Example dataset for training: XOR function
    std::vector<std::vector<double>> inputs = {
        {0.0, 0.0},
        {0.0, 1.0},
        {1.0, 0.0},
        {1.0, 1.0}
    };

    std::vector<std::vector<double>> targets = {
        {0.0},
        {1.0},
        {1.0},
        {0.0}
    };

    NeuralNetwork nn;
    nn.train(inputs, targets);

    std::cout << "Training completed.\n";

    // Test the network
    for (const auto& input : inputs) {
        std::vector<double> output = nn.forward(input);
        std::cout << "Input: ";
        for (double val : input) {
            std::cout << val << ' ';
        }
        std::cout << "-> Output: " << output[0] << std::endl;
    }

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

#include <iostream>

#include <vector>

#include <cmath>

#include <cstdlib>

#include <ctime>

const double LEARNING_RATE = 0.1;

const int INPUT_SIZE = 2;

const int HIDDEN_SIZE = 2;

const int OUTPUT_SIZE = 1;

const int NUM_EPOCHS = 10000;

// Sigmoid activation function

double sigmoid(double x) {

return 1.0 / (1.0 + std::exp(-x));

}

// Derivative of sigmoid function

double sigmoid_derivative(double x) {

return x * (1.0 - x);

}

// Neural Network class

class NeuralNetwork {

public:

NeuralNetwork() {

std::srand(std::time(0));

// Initialize weights for hidden layer and output layer

for (int i = 0; i < INPUT_SIZE; ++i) {

for (int j = 0; j < HIDDEN_SIZE; ++j) {

hiddenWeights[i][j] = (std::rand() / double(RAND_MAX)) - 0.5;

}

for (int j = 0; j < HIDDEN_SIZE; ++j) {

for (int k = 0; k < OUTPUT_SIZE; ++k) {

outputWeights[j][k] = (std::rand() / double(RAND_MAX)) - 0.5;

}

// Initialize biases

for (int j = 0; j < HIDDEN_SIZE; ++j) {

hiddenBiases[j] = (std::rand() / double(RAND_MAX)) - 0.5;

}

for (int k = 0; k < OUTPUT_SIZE; ++k) {

outputBiases[k] = (std::rand() / double(RAND_MAX)) - 0.5;

}

// Forward pass

std::vector<double> forward(const std::vector<double>& input) {

// Compute hidden layer activations

std::vector<double> hiddenLayer(HIDDEN_SIZE);

for (int j = 0; j < HIDDEN_SIZE; ++j) {

double sum = 0.0;

for (int i = 0; i < INPUT_SIZE; ++i) {

sum += input[i] * hiddenWeights[i][j];

}

sum += hiddenBiases[j];

hiddenLayer[j] = sigmoid(sum);

}

// Compute output layer activations

std::vector<double> outputLayer(OUTPUT_SIZE);

for (int k = 0; k < OUTPUT_SIZE; ++k) {

double sum = 0.0;

for (int j = 0; j < HIDDEN_SIZE; ++j) {

sum += hiddenLayer[j] * outputWeights[j][k];

}

sum += outputBiases[k];

outputLayer[k] = sigmoid(sum);

}

return outputLayer;

}

// Backpropagation to update weights

void train(const std::vector<std::vector<double>>& inputs, const std::vector<std::vector<double>>& targets) {

for (int epoch = 0; epoch < NUM_EPOCHS; ++epoch) {

for (size_t i = 0; i < inputs.size(); ++i) {

// Forward pass

std::vector<double> hiddenLayer(HIDDEN_SIZE);

std::vector<double> outputLayer(OUTPUT_SIZE);

// Compute hidden layer activations

for (int j = 0; j < HIDDEN_SIZE; ++j) {

double sum = 0.0;

for (int k = 0; k < INPUT_SIZE; ++k) {

sum += inputs[i][k] * hiddenWeights[k][j];

}

sum += hiddenBiases[j];

hiddenLayer[j] = sigmoid(sum);

}

// Compute output layer activations

for (int k = 0; k < OUTPUT_SIZE; ++k) {

double sum = 0.0;

for (int j = 0; j < HIDDEN_SIZE; ++j) {

sum += hiddenLayer[j] * outputWeights[j][k];

}

sum += outputBiases[k];

outputLayer[k] = sigmoid(sum);

}

// Backpropagation

std::vector<double> outputErrors(OUTPUT_SIZE);

for (int k = 0; k < OUTPUT_SIZE; ++k) {

outputErrors[k] = targets[i][k] - outputLayer[k];

}

std::vector<double> hiddenErrors(HIDDEN_SIZE);

for (int j = 0; j < HIDDEN_SIZE; ++j) {

hiddenErrors[j] = 0.0;

for (int k = 0; k < OUTPUT_SIZE; ++k) {

hiddenErrors[j] += outputErrors[k] * outputWeights[j][k];

}

// Update weights and biases for output layer

for (int k = 0; k < OUTPUT_SIZE; ++k) {

for (int j = 0; j < HIDDEN_SIZE; ++j) {

double delta = LEARNING_RATE * outputErrors[k] * sigmoid_derivative(outputLayer[k]) * hiddenLayer[j];

outputWeights[j][k] += delta;

}

outputBiases[k] += LEARNING_RATE * outputErrors[k] * sigmoid_derivative(outputLayer[k]);

}

// Update weights and biases for hidden layer

for (int j = 0; j < HIDDEN_SIZE; ++j) {

for (int k = 0; k < INPUT_SIZE; ++k) {

double delta = LEARNING_RATE * hiddenErrors[j] * sigmoid_derivative(hiddenLayer[j]) * inputs[i][k];

hiddenWeights[k][j] += delta;

}

hiddenBiases[j] += LEARNING_RATE * hiddenErrors[j] * sigmoid_derivative(hiddenLayer[j]);

}

private:

double hiddenWeights[INPUT_SIZE][HIDDEN_SIZE];

double outputWeights[HIDDEN_SIZE][OUTPUT_SIZE];

double hiddenBiases[HIDDEN_SIZE];

double outputBiases[OUTPUT_SIZE];

};

int main() {

// Example dataset for training: XOR function

std::vector<std::vector<double>> inputs = {

{0.0, 0.0},

{0.0, 1.0},

{1.0, 0.0},

{1.0, 1.0}

};

std::vector<std::vector<double>> targets = {

{0.0},

{1.0},

{0.0}

};

NeuralNetwork nn;

nn.train(inputs, targets);

std::cout << "Training completed.\n";

// Test the network

for (const auto& input : inputs) {

std::vector<double> output = nn.forward(input);

std::cout << "Input: ";

for (double val : input) {

std::cout << val << ' ';

}

std::cout << "-> Output: " << output[0] << std::endl;

}

return 0;

}

Explanation:

Activation Function:
- sigmoid(double x): Sigmoid activation function which squashes the input to the range [0, 1].
- sigmoid_derivative(double x): Derivative of the sigmoid function used in backpropagation.
Neural Network Class:
- Constructor: Initializes weights and biases randomly for both the hidden and output layers.
- forward(const std::vector<double>& input): Performs a forward pass through the network to compute the output given an input.
- train(const std::vector<std::vector<double>>& inputs, const std::vector<std::vector<double>>& targets): Trains the network using backpropagation. It updates the weights and biases based on the error.
Main Function:
- Defines a simple XOR dataset for training.
- Creates an instance of NeuralNetwork, trains it on the XOR dataset, and then tests the network with the training data to display the results.

Explanation:

Related Posts: