"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.scatter(X[:, 0], X[:, 1], c=y, cmap='brg')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"The neural network will not be aware of the color differences as the data have no class encodings
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"DENSE LAYER CLASS \n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 0.0000000e+00 0.0000000e+00 0.0000000e+00]\n",
" [-1.0475188e-04 1.1395361e-04 -4.7983500e-05]\n",
" [-2.7414842e-04 3.1729150e-04 -8.6921798e-05]\n",
" [-4.2188365e-04 5.2666257e-04 -5.5912682e-05]\n",
" [-5.7707680e-04 7.1401405e-04 -8.9430439e-05]]\n"
]
}
],
"source": [
"import numpy as np\n",
"import nnfs\n",
"from nnfs.datasets import spiral_data\n",
"nnfs.init()\n",
"# Dense layer\n",
"class Layer_Dense:\n",
" # Layer initialization\n",
" def __init__(self, n_inputs, n_neurons):\n",
" # Initialize weights and biases\n",
" self.weights = 0.01 * np.random.randn(n_inputs, n_neurons)\n",
" self.biases = np.zeros((1, n_neurons))\n",
"\n",
" # Forward pass\n",
" def forward(self, inputs):\n",
" # Calculate output values from inputs, weights and biases\n",
" self.output = np.dot(inputs, self.weights) + self.biases\n",
"\n",
"# Create dataset\n",
"X, y = spiral_data(samples=100, classes=3)\n",
"# Create Dense layer with 2 input features and 3 output values\n",
"dense1 = Layer_Dense(2, 3)\n",
"# Perform a forward pass of our training data through this layer\n",
"dense1.forward(X)\n",
"\n",
"\n",
"# Let's see output of the first few samples:\n",
"print(dense1.output[:5])\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"ACTIVATION FUNCTION: RELU \n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0. 2. 0. 3.3 0. 1.1 2.2 0. ]\n"
]
}
],
"source": [
"import numpy as np\n",
"inputs = [0, 2, -1, 3.3, -2.7, 1.1, 2.2, -100]\n",
"output = np.maximum(0, inputs)\n",
"print(output)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"# ReLU activation\n",
"class Activation_ReLU:\n",
" # Forward pass\n",
" def forward(self, inputs):\n",
" # Calculate output values from input\n",
" self.output = np.maximum(0, inputs)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0. 0. 0.]\n",
" [0. 0. 0.]\n",
" [0. 0. 0.]\n",
" [0. 0. 0.]\n",
" [0. 0. 0.]]\n"
]
}
],
"source": [
"# Create dataset\n",
"X, y = spiral_data(samples=100, classes=3)\n",
"# Create Dense layer with 2 input features and 3 output values\n",
"dense1 = Layer_Dense(2, 3)\n",
"# Create ReLU activation (to be used with Dense layer):\n",
"activation1 = Activation_ReLU()\n",
"# Make a forward pass of our training data through this layer\n",
"dense1.forward(X)\n",
"# Forward pass through activation func.\n",
"# Takes in output from previous layer\n",
"activation1.forward(dense1.output)\n",
"# Let's see output of the first few samples:\n",
"print(activation1.output[:5])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"ACTIVATION FUNCTION: SOFTMAX \n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"45\n",
"[12 15 18]\n",
"(3,)\n",
"[ 6 15 24]\n",
"(3,)\n",
"[[12 15 18]]\n",
"(1, 3)\n",
"[[ 6]\n",
" [15]\n",
" [24]]\n",
"(3, 1)\n",
"[7 8 9]\n",
"[3 6 9]\n"
]
}
],
"source": [
"### TRY THESE EXERCISES FOR YOURSELF!\n",
"\n",
"A = [[1, 2, 3], [4, 5, 6], [7, 8,9]]\n",
"print(np.sum(A))\n",
"\n",
"print(np.sum(A, axis = 0))\n",
"print(np.sum(A, axis = 0).shape)\n",
"\n",
"print(np.sum(A, axis = 1))\n",
"print(np.sum(A, axis = 1).shape)\n",
"\n",
"print(np.sum(A, axis = 0,keepdims = True))\n",
"print(np.sum(A, axis = 0,keepdims = True).shape)\n",
"\n",
"print(np.sum(A, axis = 1,keepdims = True))\n",
"print(np.sum(A, axis = 1,keepdims = True).shape)\n",
"\n",
"print(np.max(A, axis = 0))\n",
"print(np.max(A, axis = 1))"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0.06414769 0.17437149 0.47399085 0.28748998]\n",
" [0.04517666 0.90739747 0.00224921 0.04517666]\n",
" [0.00522984 0.34875873 0.63547983 0.0105316 ]]\n"
]
},
{
"data": {
"text/plain": [
"array([1., 1., 1.])"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"inputs = [[1, 2, 3, 2.5],\n",
" [2., 5., -1., 2],\n",
" [-1.5, 2.7, 3.3, -0.8]]\n",
"\n",
"# Get unnormalized probabilities\n",
"exp_values = np.exp(inputs - np.max(inputs, axis=1,keepdims=True))\n",
" # Normalize them for each sample\n",
"probabilities = exp_values / np.sum(exp_values, axis=1,keepdims=True)\n",
"print(probabilities)\n",
"np.sum(probabilities, axis = 1)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"# Softmax activation\n",
"class Activation_Softmax:\n",
" # Forward pass\n",
" def forward(self, inputs):\n",
" # Get unnormalized probabilities\n",
" exp_values = np.exp(inputs - np.max(inputs, axis=1, keepdims=True))\n",
" # Normalize them for each sample\n",
" probabilities = exp_values / np.sum(exp_values, axis=1,keepdims=True)\n",
" self.output = probabilities"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"ONE FORWARD PASS (WITHOUT LOSS) \n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0.33333334 0.33333334 0.33333334]\n",
" [0.33333364 0.3333334 0.3333329 ]\n",
" [0.33333385 0.3333335 0.33333266]\n",
" [0.33333433 0.3333336 0.33333206]\n",
" [0.33333462 0.33333373 0.33333164]]\n"
]
}
],
"source": [
"# Create dataset\n",
"X, y = spiral_data(samples=100, classes=3)\n",
"# Create Dense layer with 2 input features and 3 output values\n",
"dense1 = Layer_Dense(2, 3)\n",
"# Create ReLU activation (to be used with Dense layer):\n",
"activation1 = Activation_ReLU()\n",
"# Create second Dense layer with 3 input features (as we take output\n",
"# of previous layer here) and 3 output values\n",
"dense2 = Layer_Dense(3, 3)\n",
"# Create Softmax activation (to be used with Dense layer):\n",
"activation2 = Activation_Softmax()\n",
"\n",
"# Make a forward pass of our training data through this layer\n",
"dense1.forward(X)\n",
"\n",
"# Make a forward pass through activation function\n",
"# it takes the output of first dense layer here\n",
"activation1.forward(dense1.output)\n",
"# Make a forward pass through second Dense layer\n",
"# it takes outputs of activation function of first layer as inputs\n",
"dense2.forward(activation1.output)\n",
"# Make a forward pass through activation function\n",
"# it takes the output of second dense layer here\n",
"activation2.forward(dense2.output)\n",
"# Let's see output of the first few samples:\n",
"print(activation2.output[:5])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"CALCULATING NETWORK ERROR WITH LOSS \n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"CROSS ENTROPY LOSS BUILDING BLOCKS IN PYTHON\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0.7 0.5 0.9]\n"
]
}
],
"source": [
"softmax_outputs = np.array([[0.7, 0.1, 0.2],\n",
" [0.1, 0.5, 0.4],\n",
" [0.02, 0.9, 0.08]])\n",
"class_targets = [0, 1, 1]\n",
"print(softmax_outputs[range(len(softmax_outputs)), class_targets])"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"range(0, 3)"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"range(len(softmax_outputs))"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0.35667494 0.69314718 0.10536052]\n",
"0.38506088005216804\n"
]
}
],
"source": [
"print(-np.log(softmax_outputs[\n",
" range(len(softmax_outputs)), class_targets\n",
"]))\n",
"neg_log = -np.log(softmax_outputs[\n",
" range(len(softmax_outputs)), class_targets\n",
" ])\n",
"average_loss = np.mean(neg_log)\n",
"print(average_loss)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"IF DATA IS ONE HOT ENCODED, HOW TO EXTRACT THE RELEVANT PREDICTIONS\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0.35667494 0.69314718 0.10536052]\n",
"0.38506088005216804\n"
]
}
],
"source": [
"y_true_check = np.array([\n",
" [1, 0, 0],\n",
" [0, 1, 0],\n",
" [0, 1, 0]\n",
"])\n",
"\n",
"y_pred_clipped_check = np.array([\n",
" [0.7, 0.2, 0.1],\n",
" [0.1, 0.5, 0.4],\n",
" [0.02, 0.9, 0.08]\n",
"])\n",
"\n",
"A = y_true_check*y_pred_clipped_check\n",
"B = np.sum(A, axis = 1)\n",
"C = - np.log(B)\n",
"\n",
"print(C)\n",
"print(np.mean(C))\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"IMPLEMENTING THE LOSS CLASS\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Common loss class\n",
"class Loss:\n",
" # Calculates the data and regularization losses\n",
" # given model output and ground truth values\n",
" def calculate(self, output, y):\n",
" # Calculate sample losses\n",
" sample_losses = self.forward(output, y)\n",
" # Calculate mean loss\n",
" data_loss = np.mean(sample_losses)\n",
" # Return loss\n",
" return data_loss"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"IMPLEMENTING THE CATEGORICAL CROSS ENTROPY CLASS\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# Cross-entropy loss\n",
"class Loss_CategoricalCrossentropy(Loss):\n",
" # Forward pass\n",
" def forward(self, y_pred, y_true):\n",
" # Number of samples in a batch\n",
" samples = len(y_pred)\n",
" # Clip data to prevent division by 0\n",
" # Clip both sides to not drag mean towards any value\n",
" y_pred_clipped = np.clip(y_pred, 1e-7, 1 - 1e-7)\n",
" # Probabilities for target values -\n",
" # only if categorical labels\n",
" if len(y_true.shape) == 1:\n",
" correct_confidences = y_pred_clipped[\n",
" range(samples),\n",
" y_true\n",
" ]\n",
" # Mask values - only for one-hot encoded labels\n",
" elif len(y_true.shape) == 2:\n",
" correct_confidences = np.sum(\n",
" y_pred_clipped*y_true,\n",
" axis=1\n",
" )\n",
" # Losses\n",
" negative_log_likelihoods = -np.log(correct_confidences)\n",
" return negative_log_likelihoods"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.38506088005216804\n"
]
}
],
"source": [
"softmax_outputs = np.array([[0.7, 0.1, 0.2],\n",
" [0.1, 0.5, 0.4],\n",
" [0.02, 0.9, 0.08]])\n",
"class_targets = np.array([[1, 0, 0],\n",
" [0, 1, 0],\n",
" [0, 1, 0]])\n",
"loss_function = Loss_CategoricalCrossentropy()\n",
"loss = loss_function.calculate(softmax_outputs, class_targets)\n",
"print(loss)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"FULL CODE UPTO THIS POINT\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0.33333334 0.33333334 0.33333334]\n",
" [0.3333341 0.33333302 0.3333329 ]\n",
" [0.3333341 0.33333302 0.33333296]\n",
" [0.3333341 0.333333 0.33333293]\n",
" [0.3333364 0.33333203 0.33333158]]\n",
"loss: 1.0986193\n",
"acc: 0.28\n"
]
}
],
"source": [
"# Create dataset\n",
"X, y = spiral_data(samples=100, classes=3)\n",
"# Create Dense layer with 2 input features and 3 output values\n",
"dense1 = Layer_Dense(2, 3)\n",
"# Create ReLU activation (to be used with Dense layer):\n",
"activation1 = Activation_ReLU()\n",
"# Create second Dense layer with 3 input features (as we take output\n",
"# of previous layer here) and 3 output values\n",
"dense2 = Layer_Dense(3, 3)\n",
"# Create Softmax activation (to be used with Dense layer):\n",
"activation2 = Activation_Softmax()\n",
"# Create loss function\n",
"loss_function = Loss_CategoricalCrossentropy()\n",
"\n",
"\n",
"# Perform a forward pass of our training data through this layer\n",
"dense1.forward(X)\n",
"# Perform a forward pass through activation function\n",
"# it takes the output of first dense layer here\n",
"activation1.forward(dense1.output)\n",
"\n",
"# Perform a forward pass through second Dense layer\n",
"# it takes outputs of activation function of first layer as inputs\n",
"dense2.forward(activation1.output)\n",
"# Perform a forward pass through activation function\n",
"# it takes the output of second dense layer here\n",
"activation2.forward(dense2.output)\n",
"# Let's see output of the first few samples:\n",
"print(activation2.output[:5])\n",
"# Perform a forward pass through activation function\n",
"# it takes the output of second dense layer here and returns loss\n",
"loss = loss_function.calculate(activation2.output, y)\n",
"# Print loss value\n",
"print('loss:', loss)\n",
"\n",
"# Calculate accuracy from output of activation2 and targets\n",
"# calculate values along first axis\n",
"predictions = np.argmax(activation2.output, axis=1)\n",
"if len(y.shape) == 2:\n",
" y = np.argmax(y, axis=1)\n",
"accuracy = np.mean(predictions == y)\n",
"# Print accuracy\n",
"print('acc:', accuracy)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"INTRODUCING ACCURACY \n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"acc: 1.0\n"
]
}
],
"source": [
"import numpy as np\n",
"# Probabilities of 3 samples\n",
"softmax_outputs = np.array([[0.7, 0.2, 0.1],\n",
" [0.1, 0.5, 0.4],\n",
" [0.02, 0.9, 0.08]])\n",
"# Target (ground-truth) labels for 3 samples\n",
"class_targets = np.array([0, 1, 1])\n",
"# Calculate values along second axis (axis of index 1)\n",
"predictions = np.argmax(softmax_outputs, axis=1)\n",
"# If targets are one-hot encoded - convert them\n",
"if len(class_targets.shape) == 2:\n",
" class_targets = np.argmax(class_targets, axis=1)\n",
"# True evaluates to 1; False to 0\n",
"accuracy = np.mean(predictions == class_targets)\n",
"print('acc:', accuracy)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"THE NEED FOR OPTIMIZATION \n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"#SIMPLER DATASET\n",
"import matplotlib.pyplot as plt\n",
"import nnfs\n",
"from nnfs.datasets import vertical_data\n",
"nnfs.init()\n",
"X, y = vertical_data(samples=100, classes=3)\n",
"plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap='brg')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"STRATEGY 1: RANDOMLY SELECT WEIGHTS AND BIASES - DOES NOT WORK!\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"New set of weights found, iteration: 0 loss: 1.0996358 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 1 loss: 1.0993351 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 2 loss: 1.0988573 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 10 loss: 1.0988322 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 15 loss: 1.0987856 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 24 loss: 1.096816 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 340 loss: 1.0967265 acc: 0.33666666666666667\n",
"New set of weights found, iteration: 2938 loss: 1.095816 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 10848 loss: 1.0954299 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 93926 loss: 1.0950931 acc: 0.3333333333333333\n"
]
}
],
"source": [
"# Create dataset\n",
"X, y = vertical_data(samples=100, classes=3)\n",
"# Create model\n",
"dense1 = Layer_Dense(2, 3) # first dense layer, 2 inputs\n",
"activation1 = Activation_ReLU()\n",
"dense2 = Layer_Dense(3, 3) # second dense layer, 3 inputs, 3 outputs\n",
"activation2 = Activation_Softmax()\n",
"# Create loss function\n",
"loss_function = Loss_CategoricalCrossentropy()\n",
"\n",
"# Helper variables\n",
"lowest_loss = 9999999 # some initial value\n",
"best_dense1_weights = dense1.weights.copy()\n",
"best_dense1_biases = dense1.biases.copy()\n",
"best_dense2_weights = dense2.weights.copy()\n",
"best_dense2_biases = dense2.biases.copy()\n",
"\n",
"for iteration in range(100000):\n",
" # Generate a new set of weights for iteration\n",
" dense1.weights = 0.05 * np.random.randn(2, 3)\n",
" dense1.biases = 0.05 * np.random.randn(1, 3)\n",
" dense2.weights = 0.05 * np.random.randn(3, 3)\n",
" dense2.biases = 0.05 * np.random.randn(1, 3)\n",
" # Perform a forward pass of the training data through this layer\n",
" dense1.forward(X)\n",
" activation1.forward(dense1.output)\n",
" dense2.forward(activation1.output)\n",
" activation2.forward(dense2.output)\n",
" # Perform a forward pass through activation function\n",
" # it takes the output of second dense layer here and returns loss\n",
" loss = loss_function.calculate(activation2.output, y)\n",
" # Calculate accuracy from output of activation2 and targets\n",
" # calculate values along first axis\n",
" predictions = np.argmax(activation2.output, axis=1)\n",
" accuracy = np.mean(predictions == y)\n",
" # If loss is smaller - print and save weights and biases aside\n",
" if loss < lowest_loss:\n",
" print('New set of weights found, iteration:', iteration,'loss:', loss, 'acc:', accuracy)\n",
" best_dense1_weights = dense1.weights.copy()\n",
" best_dense1_biases = dense1.biases.copy()\n",
" best_dense2_weights = dense2.weights.copy()\n",
" best_dense2_biases = dense2.biases.copy()\n",
" lowest_loss = loss"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"STRATEGY 2: RANDOMLY ADJUST WEIGHTS AND BIASES - WORKS!\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'vertical_data' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m/tmp/ipykernel_169632/3189844108.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Create dataset\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvertical_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msamples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;31m# Create model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mdense1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLayer_Dense\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# first dense layer, 2 inputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mactivation1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mActivation_ReLU\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'vertical_data' is not defined"
]
}
],
"source": [
"# Create dataset\n",
"X, y = vertical_data(samples=100, classes=3)\n",
"# Create model\n",
"dense1 = Layer_Dense(2, 3) # first dense layer, 2 inputs\n",
"activation1 = Activation_ReLU()\n",
"dense2 = Layer_Dense(3, 3) # second dense layer, 3 inputs, 3 outputs\n",
"activation2 = Activation_Softmax()\n",
"# Create loss function\n",
"loss_function = Loss_CategoricalCrossentropy()\n",
"# Helper variables\n",
"lowest_loss = 9999999 # some initial value\n",
"best_dense1_weights = dense1.weights.copy()\n",
"best_dense1_biases = dense1.biases.copy()\n",
"best_dense2_weights = dense2.weights.copy()\n",
"best_dense2_biases = dense2.biases.copy()\n",
"for iteration in range(10000):\n",
" # Update weights with some small random values\n",
" dense1.weights += 0.05 * np.random.randn(2, 3)\n",
" dense1.biases += 0.05 * np.random.randn(1, 3)\n",
" dense2.weights += 0.05 * np.random.randn(3, 3)\n",
" dense2.biases += 0.05 * np.random.randn(1, 3)\n",
" # Perform a forward pass of our training data through this layer\n",
" dense1.forward(X)\n",
" activation1.forward(dense1.output)\n",
" dense2.forward(activation1.output)\n",
" activation2.forward(dense2.output)\n",
" # Perform a forward pass through activation function\n",
" # it takes the output of second dense layer here and returns loss\n",
" loss = loss_function.calculate(activation2.output, y)\n",
" # Calculate accuracy from output of activation2 and targets\n",
" # calculate values along first axis\n",
" predictions = np.argmax(activation2.output, axis=1)\n",
" accuracy = np.mean(predictions == y)\n",
" # If loss is smaller - print and save weights and biases aside\n",
" if loss < lowest_loss:\n",
" print('New set of weights found, iteration:', iteration,'loss:', loss, 'acc:', accuracy)\n",
" best_dense1_weights = dense1.weights.copy()\n",
" best_dense1_biases = dense1.biases.copy()\n",
" best_dense2_weights = dense2.weights.copy()\n",
" best_dense2_biases = dense2.biases.copy()\n",
" lowest_loss = loss\n",
" # Revert weights and biases\n",
" else:\n",
" dense1.weights = best_dense1_weights.copy()\n",
" dense1.biases = best_dense1_biases.copy()\n",
" dense2.weights = best_dense2_weights.copy()\n",
" dense2.biases = best_dense2_biases.copy()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"STRATEGY 2: FOR SPIRAL DATASET - DOES NOT WORK!\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"New set of weights found, iteration: 0 loss: 1.1005237 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 4 loss: 1.099272 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 7 loss: 1.0988917 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 12 loss: 1.0981287 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 15 loss: 1.0980351 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 26 loss: 1.0977299 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 30 loss: 1.0965452 acc: 0.39\n",
"New set of weights found, iteration: 33 loss: 1.0960287 acc: 0.38333333333333336\n",
"New set of weights found, iteration: 35 loss: 1.0959212 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 40 loss: 1.0954708 acc: 0.4066666666666667\n",
"New set of weights found, iteration: 42 loss: 1.0949016 acc: 0.35\n",
"New set of weights found, iteration: 45 loss: 1.0948775 acc: 0.43\n",
"New set of weights found, iteration: 51 loss: 1.0944252 acc: 0.3333333333333333\n",
"New set of weights found, iteration: 56 loss: 1.0941274 acc: 0.39666666666666667\n",
"New set of weights found, iteration: 61 loss: 1.0938694 acc: 0.38333333333333336\n",
"New set of weights found, iteration: 62 loss: 1.0938368 acc: 0.33\n",
"New set of weights found, iteration: 68 loss: 1.0937221 acc: 0.35333333333333333\n",
"New set of weights found, iteration: 69 loss: 1.0926502 acc: 0.36\n",
"New set of weights found, iteration: 70 loss: 1.0913934 acc: 0.36\n",
"New set of weights found, iteration: 71 loss: 1.0903853 acc: 0.38666666666666666\n",
"New set of weights found, iteration: 72 loss: 1.0899442 acc: 0.38\n",
"New set of weights found, iteration: 75 loss: 1.0879555 acc: 0.36666666666666664\n",
"New set of weights found, iteration: 76 loss: 1.0864727 acc: 0.4166666666666667\n",
"New set of weights found, iteration: 80 loss: 1.084729 acc: 0.4\n",
"New set of weights found, iteration: 98 loss: 1.0840615 acc: 0.3933333333333333\n",
"New set of weights found, iteration: 107 loss: 1.0840529 acc: 0.37333333333333335\n",
"New set of weights found, iteration: 112 loss: 1.0840163 acc: 0.35333333333333333\n",
"New set of weights found, iteration: 113 loss: 1.081911 acc: 0.3933333333333333\n",
"New set of weights found, iteration: 118 loss: 1.0809788 acc: 0.4066666666666667\n",
"New set of weights found, iteration: 129 loss: 1.0806961 acc: 0.42\n",
"New set of weights found, iteration: 133 loss: 1.0801857 acc: 0.39666666666666667\n",
"New set of weights found, iteration: 135 loss: 1.0792507 acc: 0.38666666666666666\n",
"New set of weights found, iteration: 159 loss: 1.0787331 acc: 0.4\n",
"New set of weights found, iteration: 199 loss: 1.0785424 acc: 0.41\n",
"New set of weights found, iteration: 219 loss: 1.0783063 acc: 0.4033333333333333\n",
"New set of weights found, iteration: 240 loss: 1.0780586 acc: 0.4266666666666667\n",
"New set of weights found, iteration: 251 loss: 1.077764 acc: 0.41333333333333333\n",
"New set of weights found, iteration: 254 loss: 1.0777346 acc: 0.4\n",
"New set of weights found, iteration: 255 loss: 1.0771401 acc: 0.42\n",
"New set of weights found, iteration: 258 loss: 1.0770148 acc: 0.42333333333333334\n",
"New set of weights found, iteration: 259 loss: 1.0763383 acc: 0.45666666666666667\n",
"New set of weights found, iteration: 261 loss: 1.0741296 acc: 0.4266666666666667\n",
"New set of weights found, iteration: 270 loss: 1.0740651 acc: 0.45\n",
"New set of weights found, iteration: 290 loss: 1.0738546 acc: 0.42333333333333334\n",
"New set of weights found, iteration: 312 loss: 1.0727702 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 316 loss: 1.072282 acc: 0.39666666666666667\n",
"New set of weights found, iteration: 317 loss: 1.0719106 acc: 0.4033333333333333\n",
"New set of weights found, iteration: 322 loss: 1.0713525 acc: 0.43666666666666665\n",
"New set of weights found, iteration: 350 loss: 1.071252 acc: 0.43666666666666665\n",
"New set of weights found, iteration: 362 loss: 1.0706744 acc: 0.44\n",
"New set of weights found, iteration: 369 loss: 1.0706185 acc: 0.44333333333333336\n",
"New set of weights found, iteration: 408 loss: 1.0704075 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 420 loss: 1.0703163 acc: 0.4666666666666667\n",
"New set of weights found, iteration: 504 loss: 1.0700997 acc: 0.46\n",
"New set of weights found, iteration: 547 loss: 1.069801 acc: 0.45\n",
"New set of weights found, iteration: 849 loss: 1.0697782 acc: 0.44666666666666666\n",
"New set of weights found, iteration: 1100 loss: 1.0697608 acc: 0.45666666666666667\n",
"New set of weights found, iteration: 2395 loss: 1.069701 acc: 0.43666666666666665\n",
"New set of weights found, iteration: 2432 loss: 1.0696893 acc: 0.43\n",
"New set of weights found, iteration: 2839 loss: 1.0696803 acc: 0.44333333333333336\n",
"New set of weights found, iteration: 2848 loss: 1.0695381 acc: 0.45\n",
"New set of weights found, iteration: 2871 loss: 1.0695071 acc: 0.45666666666666667\n",
"New set of weights found, iteration: 3036 loss: 1.0694591 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 3505 loss: 1.0694478 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 3551 loss: 1.0693843 acc: 0.44666666666666666\n",
"New set of weights found, iteration: 3583 loss: 1.0689726 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 4425 loss: 1.0688362 acc: 0.44\n",
"New set of weights found, iteration: 4458 loss: 1.0686082 acc: 0.4266666666666667\n",
"New set of weights found, iteration: 4464 loss: 1.0682111 acc: 0.45\n",
"New set of weights found, iteration: 4466 loss: 1.0681838 acc: 0.45\n",
"New set of weights found, iteration: 4468 loss: 1.0680927 acc: 0.44\n",
"New set of weights found, iteration: 4490 loss: 1.0676068 acc: 0.46\n",
"New set of weights found, iteration: 4567 loss: 1.0675108 acc: 0.44\n",
"New set of weights found, iteration: 4585 loss: 1.0671601 acc: 0.45\n",
"New set of weights found, iteration: 4608 loss: 1.0668906 acc: 0.46\n",
"New set of weights found, iteration: 4645 loss: 1.0667204 acc: 0.44666666666666666\n",
"New set of weights found, iteration: 4657 loss: 1.0661545 acc: 0.44\n",
"New set of weights found, iteration: 4728 loss: 1.0658569 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 4736 loss: 1.0651729 acc: 0.43\n",
"New set of weights found, iteration: 4804 loss: 1.0649427 acc: 0.43\n",
"New set of weights found, iteration: 4805 loss: 1.0647476 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 4807 loss: 1.0638916 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 4832 loss: 1.0638343 acc: 0.45\n",
"New set of weights found, iteration: 4975 loss: 1.0636576 acc: 0.44333333333333336\n",
"New set of weights found, iteration: 4981 loss: 1.0631315 acc: 0.45\n",
"New set of weights found, iteration: 4994 loss: 1.0625263 acc: 0.44333333333333336\n",
"New set of weights found, iteration: 5086 loss: 1.0624654 acc: 0.46\n",
"New set of weights found, iteration: 5108 loss: 1.06243 acc: 0.4266666666666667\n",
"New set of weights found, iteration: 5116 loss: 1.062381 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 5129 loss: 1.062371 acc: 0.45666666666666667\n",
"New set of weights found, iteration: 5135 loss: 1.0610354 acc: 0.44333333333333336\n",
"New set of weights found, iteration: 5141 loss: 1.0599765 acc: 0.43\n",
"New set of weights found, iteration: 5170 loss: 1.0597756 acc: 0.43666666666666665\n",
"New set of weights found, iteration: 5176 loss: 1.0596782 acc: 0.44666666666666666\n",
"New set of weights found, iteration: 5200 loss: 1.0585961 acc: 0.45\n",
"New set of weights found, iteration: 5443 loss: 1.0584674 acc: 0.45666666666666667\n",
"New set of weights found, iteration: 5447 loss: 1.0584322 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 5456 loss: 1.0581532 acc: 0.43\n",
"New set of weights found, iteration: 5507 loss: 1.0578263 acc: 0.44\n",
"New set of weights found, iteration: 5509 loss: 1.0575186 acc: 0.44\n",
"New set of weights found, iteration: 5551 loss: 1.0564784 acc: 0.43666666666666665\n",
"New set of weights found, iteration: 5562 loss: 1.0564457 acc: 0.4666666666666667\n",
"New set of weights found, iteration: 5618 loss: 1.0563129 acc: 0.46\n",
"New set of weights found, iteration: 5650 loss: 1.056275 acc: 0.43666666666666665\n",
"New set of weights found, iteration: 5697 loss: 1.0562539 acc: 0.43\n",
"New set of weights found, iteration: 5704 loss: 1.0562011 acc: 0.44333333333333336\n",
"New set of weights found, iteration: 5715 loss: 1.0553932 acc: 0.4666666666666667\n",
"New set of weights found, iteration: 5727 loss: 1.0553335 acc: 0.44333333333333336\n",
"New set of weights found, iteration: 5743 loss: 1.05487 acc: 0.4266666666666667\n",
"New set of weights found, iteration: 5824 loss: 1.0542839 acc: 0.45\n",
"New set of weights found, iteration: 5828 loss: 1.054109 acc: 0.44666666666666666\n",
"New set of weights found, iteration: 5831 loss: 1.0539638 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 5868 loss: 1.0535976 acc: 0.44666666666666666\n",
"New set of weights found, iteration: 6097 loss: 1.053527 acc: 0.44\n",
"New set of weights found, iteration: 6269 loss: 1.0534726 acc: 0.44666666666666666\n",
"New set of weights found, iteration: 6382 loss: 1.0534171 acc: 0.4166666666666667\n",
"New set of weights found, iteration: 6383 loss: 1.0532491 acc: 0.41\n",
"New set of weights found, iteration: 6437 loss: 1.0530741 acc: 0.4033333333333333\n",
"New set of weights found, iteration: 6448 loss: 1.0529624 acc: 0.41333333333333333\n",
"New set of weights found, iteration: 6489 loss: 1.0526949 acc: 0.42333333333333334\n",
"New set of weights found, iteration: 6509 loss: 1.0526203 acc: 0.4633333333333333\n",
"New set of weights found, iteration: 6510 loss: 1.0524963 acc: 0.44333333333333336\n",
"New set of weights found, iteration: 6532 loss: 1.0524482 acc: 0.43\n",
"New set of weights found, iteration: 6544 loss: 1.0522528 acc: 0.44\n",
"New set of weights found, iteration: 6632 loss: 1.052054 acc: 0.45666666666666667\n",
"New set of weights found, iteration: 6674 loss: 1.0520425 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 6719 loss: 1.0514716 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 6786 loss: 1.0514234 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 6834 loss: 1.0511931 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 6989 loss: 1.0511316 acc: 0.46\n",
"New set of weights found, iteration: 7071 loss: 1.0510049 acc: 0.4666666666666667\n",
"New set of weights found, iteration: 7213 loss: 1.0507108 acc: 0.4533333333333333\n",
"New set of weights found, iteration: 7618 loss: 1.0503324 acc: 0.46\n",
"New set of weights found, iteration: 7782 loss: 1.0500554 acc: 0.4633333333333333\n",
"New set of weights found, iteration: 8259 loss: 1.049952 acc: 0.45666666666666667\n",
"New set of weights found, iteration: 8287 loss: 1.0498099 acc: 0.42333333333333334\n",
"New set of weights found, iteration: 8343 loss: 1.0492009 acc: 0.44666666666666666\n",
"New set of weights found, iteration: 8352 loss: 1.0491385 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 8408 loss: 1.0489689 acc: 0.41333333333333333\n",
"New set of weights found, iteration: 8431 loss: 1.0489289 acc: 0.42333333333333334\n",
"New set of weights found, iteration: 8573 loss: 1.0487736 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 8704 loss: 1.0485046 acc: 0.4266666666666667\n",
"New set of weights found, iteration: 8753 loss: 1.0484601 acc: 0.4166666666666667\n",
"New set of weights found, iteration: 8999 loss: 1.0484053 acc: 0.4\n",
"New set of weights found, iteration: 9121 loss: 1.0479419 acc: 0.39666666666666667\n",
"New set of weights found, iteration: 9329 loss: 1.0479223 acc: 0.43333333333333335\n",
"New set of weights found, iteration: 9330 loss: 1.0475453 acc: 0.42\n",
"New set of weights found, iteration: 9395 loss: 1.0470929 acc: 0.43\n",
"New set of weights found, iteration: 9490 loss: 1.0470548 acc: 0.4166666666666667\n",
"New set of weights found, iteration: 9607 loss: 1.046979 acc: 0.4166666666666667\n",
"New set of weights found, iteration: 9821 loss: 1.0469537 acc: 0.4\n",
"New set of weights found, iteration: 9835 loss: 1.0469226 acc: 0.41333333333333333\n",
"New set of weights found, iteration: 9858 loss: 1.0468988 acc: 0.41\n",
"New set of weights found, iteration: 9867 loss: 1.0468199 acc: 0.41333333333333333\n",
"New set of weights found, iteration: 9877 loss: 1.0466912 acc: 0.39666666666666667\n",
"New set of weights found, iteration: 9892 loss: 1.0462589 acc: 0.3933333333333333\n",
"New set of weights found, iteration: 9908 loss: 1.0462073 acc: 0.4033333333333333\n"
]
}
],
"source": [
"# Create dataset\n",
"X, y = spiral_data(samples=100, classes=3)# Create model\n",
"dense1 = Layer_Dense(2, 3) # first dense layer, 2 inputs\n",
"activation1 = Activation_ReLU()\n",
"dense2 = Layer_Dense(3, 3) # second dense layer, 3 inputs, 3 outputs\n",
"activation2 = Activation_Softmax()\n",
"# Create loss function\n",
"loss_function = Loss_CategoricalCrossentropy()\n",
"# Helper variables\n",
"lowest_loss = 9999999 # some initial value\n",
"best_dense1_weights = dense1.weights.copy()\n",
"best_dense1_biases = dense1.biases.copy()\n",
"best_dense2_weights = dense2.weights.copy()\n",
"best_dense2_biases = dense2.biases.copy()\n",
"for iteration in range(10000):\n",
" # Update weights with some small random values\n",
" dense1.weights += 0.05 * np.random.randn(2, 3)\n",
" dense1.biases += 0.05 * np.random.randn(1, 3)\n",
" dense2.weights += 0.05 * np.random.randn(3, 3)\n",
" dense2.biases += 0.05 * np.random.randn(1, 3)\n",
" # Perform a forward pass of our training data through this layer\n",
" dense1.forward(X)\n",
" activation1.forward(dense1.output)\n",
" dense2.forward(activation1.output)\n",
" activation2.forward(dense2.output)\n",
" # Perform a forward pass through activation function\n",
" # it takes the output of second dense layer here and returns loss\n",
" loss = loss_function.calculate(activation2.output, y)\n",
" # Calculate accuracy from output of activation2 and targets\n",
" # calculate values along first axis\n",
" predictions = np.argmax(activation2.output, axis=1)\n",
" accuracy = np.mean(predictions == y)\n",
" # If loss is smaller - print and save weights and biases aside\n",
" if loss < lowest_loss:\n",
" print('New set of weights found, iteration:', iteration,'loss:', loss, 'acc:', accuracy)\n",
" best_dense1_weights = dense1.weights.copy()\n",
" best_dense1_biases = dense1.biases.copy()\n",
" best_dense2_weights = dense2.weights.copy()\n",
" best_dense2_biases = dense2.biases.copy()\n",
" lowest_loss = loss\n",
" # Revert weights and biases\n",
" else:\n",
" dense1.weights = best_dense1_weights.copy()\n",
" dense1.biases = best_dense1_biases.copy()\n",
" dense2.weights = best_dense2_weights.copy()\n",
" dense2.biases = best_dense2_biases.copy()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.12"
}
},
"nbformat": 4,
"nbformat_minor": 4
}