and-link-example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AndLink and EvaluationLink examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import common\n",
    "from opencog.utilities import initialize_opencog\n",
    "from opencog.atomspace import AtomSpace, types\n",
    "from opencog.type_constructors import *\n",
    "from opencog.bindlink import execute_atom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "create atomspace and set it as default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "atomspace = AtomSpace()\n",
    "initialize_opencog(atomspace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### knowledge base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Color and size are attributes.  \n",
    "InheritanceLink is similiar to verb \"is\" like it is used in natural languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "InheritanceLink(ConceptNode(\"size\"), ConceptNode(\"attribute\"))\n",
    "InheritanceLink(ConceptNode(\"color\"), ConceptNode(\"attribute\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different types of color and size  \n",
    "PredicateNode is used to define relations between different objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "InheritanceLink(PredicateNode(\"small\"), ConceptNode(\"size\"))\n",
    "InheritanceLink(PredicateNode(\"big\"), ConceptNode(\"size\"))\n",
    "InheritanceLink(PredicateNode(\"green\"), ConceptNode(\"color\"))\n",
    "InheritanceLink(PredicateNode(\"red\"), ConceptNode(\"color\"))\n",
    "InheritanceLink(PredicateNode(\"black\"), ConceptNode(\"color\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "animals which have some attributes defined using EvaluationLink  \n",
    "EvaluationLink defines predicate for particular objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def assign_property(concept, relation, tv):\n",
    "    EvaluationLink(relation,\n",
    "                   concept).tv = TruthValue(*tv)\n",
    "\n",
    "assign_property(ConceptNode(\"frog\"), PredicateNode(\"small\"), (0.8, 0.6))\n",
    "assign_property(ConceptNode(\"frog\"), PredicateNode(\"green\"), (0.7, 0.91))\n",
    "assign_property(ConceptNode(\"tiger\"), PredicateNode(\"big\"), (0.9, 0.92))\n",
    "assign_property(ConceptNode(\"tiger\"), PredicateNode(\"red\"), (0.6, 0.83))\n",
    "assign_property(ConceptNode(\"sparrow\"), PredicateNode(\"red\"), (0.1, 0.64))\n",
    "assign_property(ConceptNode(\"sparrow\"), PredicateNode(\"small\"), (0.8, 0.77))\n",
    "assign_property(ConceptNode(\"zebra\"), PredicateNode(\"black\"), (0.5, 0.9))\n",
    "assign_property(ConceptNode(\"zebra\"), PredicateNode(\"small\"), (0.38, 0.89))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define that all animals are actually animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "InheritanceLink(ConceptNode(\"frog\"), ConceptNode(\"animal\"))\n",
    "InheritanceLink(ConceptNode(\"frog\"), ConceptNode(\"animal\"))\n",
    "InheritanceLink(ConceptNode(\"tiger\"), ConceptNode(\"animal\"))\n",
    "InheritanceLink(ConceptNode(\"tiger\"), ConceptNode(\"animal\"))\n",
    "InheritanceLink(ConceptNode(\"sparrow\"), ConceptNode(\"animal\"))\n",
    "InheritanceLink(ConceptNode(\"sparrow\"), ConceptNode(\"animal\"))\n",
    "InheritanceLink(ConceptNode(\"zebra\"), ConceptNode(\"animal\"))\n",
    "InheritanceLink(ConceptNode(\"zebra\"), ConceptNode(\"animal\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Basic query example**\n",
    "\n",
    "select all red animals:  \n",
    "Find all the EvaluationLink with predicate \"red\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bind_link = BindLink(\n",
    "                   EvaluationLink(PredicateNode(\"red\"),\n",
    "                                  VariableNode(\"X\")),\n",
    "                   VariableNode(\"X\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(execute_atom(atomspace, bind_link))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Query example**  \n",
    "let's select all animals and attributes, filtering by some threshold\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "first define function and EvaluationLink"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0.6\n",
    "\n",
    "def apply_threshold(atom):\n",
    "    if atom.tv.mean < threshold:\n",
    "        return TruthValue(0, 1)\n",
    "    return TruthValue(1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constrain Variable(\"X\") is animal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_animal = InheritanceLink(VariableNode(\"X\"), \n",
    "                            ConceptNode(\"animal\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "EvaluationLink will accept link    X <- \"animal\" \n",
    "and return flag if it \"matches\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicate = EvaluationLink(VariableNode(\"$B\"),\n",
    "                           VariableNode(\"X\"))\n",
    "\n",
    "eval_threshold = EvaluationLink(\n",
    "                    GroundedPredicateNode(\"py: apply_threshold\"),\n",
    "                    ListLink(predicate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "first define pattern that will be grounded during the search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "and_link = AndLink(is_animal,\n",
    "                   predicate,\n",
    "                   eval_threshold\n",
    "                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### now build the BindLink\n",
    "BindLink is constructed using pattern to ground and pattern to return.  \n",
    "pattern to return if it contains variables,  \n",
    "should be part of pattern to ground"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bindlink_filter = BindLink(and_link,\n",
    "                           predicate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "execute query"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(execute_atom(atomspace, bindlink_filter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: use atom.tv.confidence\n",
    "\n",
    "in threshold function"
   ]
  }
 ],
 "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}