Adaptive_Resonance_Theory.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Adaptive Resonance Theory.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "3cIYAalQKkAd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "import math\n",
        "import sys\n",
        "\n",
        "N = 4 # Number of components in an input vector.\n",
        "M = 5 # Max number of clusters to be formed.\n",
        "VIGILANCE = 0.4\n",
        "\n",
        "PATTERN_ARRAY = [[1, 1, 0, 0], \n",
        "                 [0, 0, 0, 1], \n",
        "                 [1, 0, 0, 0], \n",
        "                 [0, 0, 1, 1], \n",
        "                 [0, 1, 0, 0], \n",
        "                 [0, 0, 1, 0], \n",
        "                 [1, 0, 1, 0]]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WOLqVPR9LHM8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "class ART1:\n",
        "    def __init__(self, inputSize, numClusters, vigilance):\n",
        "        self.mInputSize = inputSize\n",
        "        self.mNumClusters = numClusters\n",
        "        self.mVigilance = vigilance\n",
        "        \n",
        "        self.bw = [] # Bottom-up weights.\n",
        "        self.tw = [] # Top-down weights.\n",
        "\n",
        "        self.f1a = [] # Input layer.\n",
        "        self.f1b = [] # Interface layer.\n",
        "        self.f2 = []\n",
        "\t\t#initialize bottom-up weight matrix.\n",
        "        for i in range(self.mNumClusters):\n",
        "            self.bw.append([0.0] * self.mInputSize)\n",
        "            for j in range(self.mInputSize):\n",
        "                self.bw[i][j] = 1.0 / (1.0 + self.mInputSize)\n",
        "        \n",
        "        # Initialize top-down weight matrix.\n",
        "        for i in range(self.mNumClusters):\n",
        "            self.tw.append([0.0] * self.mInputSize)\n",
        "            for j in range(self.mInputSize):\n",
        "                self.tw[i][j] = 1.0\n",
        "\n",
        "        self.f1a = [0.0] * self.mInputSize\n",
        "        self.f1b = [0.0] * self.mInputSize\n",
        "        self.f2 = [0.0] * self.mNumClusters\n",
        "        \n",
        "    \n",
        "    def get_vector_sum(self, nodeArray):\n",
        "        total = 0\n",
        "        for i in range(len(nodeArray)):\n",
        "            total += nodeArray[i]\n",
        "        return total\n",
        "    \n",
        "    def get_maximum(self, nodeArray):\n",
        "        maximum = -1\n",
        "        maxValue = -0\n",
        "        unique = True\n",
        "        for i in range(len(nodeArray)):\n",
        "            if nodeArray[i] > maxValue:\n",
        "                maximum = i\n",
        "                maxValue = nodeArray[i]\n",
        "        return maximum\n",
        "    \n",
        "    def test_for_reset(self, activationSum, inputSum, f2Max):\n",
        "        if(inputSum == 0): return False\n",
        "        elif(float(activationSum) / float(inputSum) >= self.mVigilance):\n",
        "            return False # Candidate is accepted.\n",
        "        else:\n",
        "            self.f2[f2Max] = -1.0 # Inhibit.\n",
        "            return True # Candidate is rejected.\n",
        "    \n",
        "    def update_weights(self, activationSum, f2Max):\n",
        "        # Update bw(f2Max)\n",
        "        for i in range(self.mInputSize):\n",
        "            self.bw[f2Max][i] = (2.0 * float(self.f1b[i])) / (1.0 + float(activationSum))\n",
        "        \n",
        "        \n",
        "        # Update tw(f2Max)\n",
        "        for i in range(self.mInputSize):\n",
        "            self.tw[f2Max][i] = self.f1b[i]\n",
        "\n",
        "    def ART1(self, trainingPattern, isTraining):\n",
        "        inputSum = 0\n",
        "        activationSum = 0\n",
        "        f2Max = 0\n",
        "        reset = True\n",
        "        \n",
        "\n",
        "        # Initialize f2 layer activations to 0.0\n",
        "        for i in range(self.mNumClusters):\n",
        "            self.f2[i] = 0.0\n",
        "        \n",
        "        # Input pattern() to f1 layer.\n",
        "        for i in range(self.mInputSize):\n",
        "            self.f1a[i] = float(trainingPattern[i])\n",
        "        \n",
        "        # Compute sum of input pattern.\n",
        "        inputSum = self.get_vector_sum(self.f1a)\n",
        "\t\t\n",
        "#        if inputSum == 0:\n",
        "#            return None\n",
        "        \n",
        "        # Compute activations for each node in the f1 layer.\n",
        "        # Send input signal from f1a to the fF1b layer.\n",
        "        for i in range(self.mInputSize):\n",
        "            self.f1b[i] = self.f1a[i]\n",
        "            \n",
        "        # Compute net input for each node in the f2 layer.\n",
        "        for i in range(self.mNumClusters):\n",
        "            for j in range(self.mInputSize):\n",
        "                self.f2[i] += self.bw[i][j] * float(self.f1a[j])\n",
        "           \n",
        "        reset = True\n",
        "        while reset:\n",
        "            # Determine the largest value of the f2 nodes.\n",
        "            f2Max = self.get_maximum(self.f2)\n",
        "            \n",
        "\t\t\t# If there is no maximum, add a new node\n",
        "            if f2Max == -1:\n",
        "                f2Max = self.mNumClusters\n",
        "                self.f2.append(0.0)\n",
        "                self.tw.append([1.0] * self.mInputSize)\n",
        "                self.bw.append([1.0 / (1.0 + self.mInputSize)] * self.mInputSize)\n",
        "                self.mNumClusters+=1\n",
        "\n",
        "\t\t\t\n",
        "            # Recompute the f1a to f1b activations (perform AND function)\n",
        "            for i in range(self.mInputSize):\n",
        "                self.f1b[i] = self.f1a[i] * math.floor(self.tw[f2Max][i])\n",
        "\n",
        "            # Compute sum of input pattern.\n",
        "            activationSum = self.get_vector_sum(self.f1b)\n",
        "            reset = self.test_for_reset(activationSum, inputSum, f2Max)\n",
        "           \n",
        "        # if we are training, train the network\n",
        "        if isTraining:\n",
        "            self.update_weights(activationSum, f2Max)\n",
        "            \n",
        "        return f2Max\n",
        "    \n",
        "    def print_results(self):\n",
        "        sys.stdout.write(\"Clusters found: \" + str(self. mNumClusters) + \"\\n\")\n",
        "        sys.stdout.write(\"Rho: \" + str(self.mVigilance) + \"\\n\\n\")\n",
        "        sys.stdout.write(\"Final weight values:\\n\")\n",
        "        \n",
        "        for i in range(self.mNumClusters):\n",
        "            for j in range(self.mInputSize):\n",
        "                sys.stdout.write(str(self.bw[i][j]) + \", \")\n",
        "            \n",
        "            sys.stdout.write(\"\\n\")\n",
        "        sys.stdout.write(\"\\n\")\n",
        "        \n",
        "        for i in range(self.mNumClusters):\n",
        "            for j in range(self.mInputSize):\n",
        "                sys.stdout.write(str(self.tw[i][j]) + \", \")\n",
        "            \n",
        "            sys.stdout.write(\"\\n\")\n",
        "        sys.stdout.write(\"\\n\")\n",
        "        return"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zIk8X5nPLkaZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "e75d2c80-2b22-4d74-b0fa-f9b39eaaeb91"
      },
      "source": [
        "if __name__ == '__main__':\n",
        "    net = ART1(N, M, VIGILANCE)\n",
        "    for line in PATTERN_ARRAY:\n",
        "        net.ART1(line, True)\n",
        "    for line in PATTERN_ARRAY:\n",
        "        print(str(line) + ',' + str(net.ART1(line, True)))"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 1, 0, 0],0\n",
            "[0, 0, 0, 1],1\n",
            "[1, 0, 0, 0],0\n",
            "[0, 0, 1, 1],1\n",
            "[0, 1, 0, 0],2\n",
            "[0, 0, 1, 0],3\n",
            "[1, 0, 1, 0],0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bBKT8qofLr2y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}