v1-6-2-14-Copy0.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import collection.mutable.{ArrayBuffer, Set, Map}\n",
      "import cc.factorie.variable.{CategoricalDomain, CategoricalVariable, DiffList, Var}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "implicit val random = new scala.util.Random(0)\n",
      "implicit val d = new DiffList"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 3,
       "text": [
        "DiffList()"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "object spinDomain extends CategoricalDomain[Char]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "CategoricalDomain[](0)"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Spin(value: Char, val i: Int) extends CategoricalVariable[Char](value){\n",
      "    def domain = spinDomain\n",
      "    var cont: IndexedSeq[Spin] = null\n",
      "    def setContainer(c: IndexedSeq[Spin]): Unit = {this.cont = c}\n",
      "    override def toString = this.value.toString\n",
      "    \n",
      "}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def generateSpinVector(s: String): IndexedSeq[Spin] = {\n",
      "    val variables = for((s, i) <- s.zipWithIndex) yield new Spin(s, i)\n",
      "    variables.foreach(_.setContainer(variables))\n",
      "    variables\n",
      "}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class SpinContainer(values: String){\n",
      "    val variables = for((s, i) <- values.zipWithIndex) yield new Spin(s, i)\n",
      "    //variables.foreach(_.setContainer(this))\n",
      "    def apply(i: Int) = variables(i)\n",
      "}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import cc.factorie.model.{Parameters, Model, Factor, DotFamilyWithStatistics1, DotFamilyWithStatistics2}\n",
      "import cc.factorie.la.{DenseTensor1, DenseTensor2}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for(i <- 1 to 5) print(i)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "12345"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class PottsModel(val num: Int, val spinDomain: CategoricalDomain[Char]) extends Model with Parameters {\n",
      "    val domSize = spinDomain.size\n",
      "    \n",
      "    val localFamilies = for(i <- 0 until num) yield new DotFamilyWithStatistics1[Spin] {val weights = Weights(new DenseTensor1(domSize))}\n",
      "    \n",
      "    val pairwiseFamilies = Map[(Int, Int), DotFamilyWithStatistics2[Spin, Spin]]()\n",
      "    for(i <- 0 until num; j <- 0 until num if i != j) { \n",
      "        pairwiseFamilies += ((i, j) -> new DotFamilyWithStatistics2[Spin, Spin] {\n",
      "            val weights = Weights(new DenseTensor2(domSize, domSize))\n",
      "        })\n",
      "    }\n",
      "            \n",
      "    def factors(variables: Iterable[Var]): Iterable[Factor] = {\n",
      "        val results = new ArrayBuffer[Factor]\n",
      "        \n",
      "        val spins = variables collect {case s: Spin => s}\n",
      "        \n",
      "        for(s <- spins){\n",
      "                val i = s.i\n",
      "                val localFamiliy = localFamilies(i)\n",
      "                results += localFamiliy.Factor(s)\n",
      "                \n",
      "                val spinContainer = s.cont\n",
      "                val pKeys = pairwiseFamilies.keys.filter((k: Pair[Int, Int]) => k._1 == i || k._2 == i)\n",
      "                for(k <- pKeys) {\n",
      "                    val pairwiseFamily = pairwiseFamilies(k)\n",
      "                    //TODO: is the order of variable important here?\n",
      "                    results += pairwiseFamily.Factor(spinContainer(k._1), spinContainer(k._2))\n",
      "                }\n",
      "        }\n",
      "        results\n",
      "    }\n",
      "    \n",
      "    \n",
      "}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "val myData = List(\n",
      "                  \"A0E0B\",\n",
      "                  \"A0E0B\",\n",
      "                  \"D0E0C\",\n",
      "                  \"A0E0B\",\n",
      "                  \"D0E0C\",\n",
      "                  \"A0E0B\",\n",
      "                  \"D0E0C\",\n",
      "                  \"A0E0B\",\n",
      "                  \"A0E0B\",\n",
      "                  \"D0E0D\"\n",
      "                  )\n",
      "val myVaribs = for(e <- myData) yield generateSpinVector(e)\n",
      "val model = new PottsModel(5, spinDomain)\n",
      "model.factors(myVaribs(0))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 11,
       "text": [
        "ArrayBuffer(PottsModel$$anonfun$2$$anon$1(A), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(A,E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(B,A), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(E,A), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(A,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,A), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(A,B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(A,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,A), PottsModel$$anonfun$2$$anon$1(0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(B,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(A,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(E,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,A), PottsModel$$anonfun$2$$anon$1(E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(A,E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(E,A), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(B,E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(E,B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(E,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(E,0), PottsModel$$anonfun$2$$anon$1(0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(A,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,A), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(E,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(B,0), PottsModel$$anonfun$2$$anon$1(B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(B,A), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(B,0), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(0,B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(A,B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(B,E), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(E,B), PottsModel$$anonfun$4$$anonfun$apply$mcVI$sp$2$$anon$2(B,0))"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myVaribs(0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "Vector(A, 0, E, 0, B)"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import cc.factorie.optimize.{AdaGrad, Trainer, LikelihoodExample}\n",
      "import cc.factorie.infer.{InferByMeanField, InferByBPLoopy}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "val examples = myVaribs.map(v => new LikelihoodExample(v, model, InferByBPLoopy))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 14,
       "text": [
        "List(cc.factorie.optimize.LikelihoodExample@4746665b, cc.factorie.optimize.LikelihoodExample@5eea04eb, cc.factorie.optimize.LikelihoodExample@55e910fb, cc.factorie.optimize.LikelihoodExample@3859facd, cc.factorie.optimize.LikelihoodExample@1b60c5a2, cc.factorie.optimize.LikelihoodExample@6e4f1cb8, cc.factorie.optimize.LikelihoodExample@be6ac9c, cc.factorie.optimize.LikelihoodExample@554e3bde, cc.factorie.optimize.LikelihoodExample@33c9793, cc.factorie.optimize.LikelihoodExample@7f03358d)"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "spinDomain._elements"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "ArrayBuffer(A, 0, E, B, D, C)"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "val optimizer0 = new AdaGrad()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "cc.factorie.optimize.AdaGrad@4085c33e"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Trainer.onlineTrain(model.parameters, examples)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "model.parameters.keys"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 18,
       "text": [
        "ArrayBuffer(anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_), anon(_))"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "val w1 = model.parameters(model.pairwiseFamilies(0, 4).weights).asInstanceOf[DenseTensor2]\n",
      "val w2 = model.parameters(model.pairwiseFamilies(1, 2).weights)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 23,
       "text": [
        "DenseTensor2(-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,0.0,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462)"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "val w1 = model.parameters(model.pairwiseFamilies(0, 4).weights).asInstanceOf[Tensor2]\n",
      "val w2 = model.parameters(model.pairwiseFamilies(1, 2).weights).asInstanceOf[Tensor2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "ename": "",
       "evalue": "",
       "output_type": "pyerr",
       "traceback": [
        "<console>:19: error: not found: type Tensor2",
        "       val w1 = model.parameters(model.pairwiseFamilies(0, 4).weights).asInstanceOf[Tensor2]",
        "                                                                                    ^",
        "<console>:20: error: not found: type Tensor2",
        "       val w2 = model.parameters(model.pairwiseFamilies(1, 2).weights).asInstanceOf[Tensor2]",
        "                                                                                    ^"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "w1 - 5"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "",
       "evalue": "",
       "output_type": "pyerr",
       "traceback": [
        "<console>:21: error: type mismatch;",
        " found   : Int(5)",
        " required: cc.factorie.la.Tensor",
        "              w1 - 5",
        "                   ^"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import cc.factorie.la.DenseTensor2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      }
     ],
     "prompt_number": 40
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "val w = new DenseTensor2(List(List(0.1, -0.2, 0.3), List(-0.2, 0., -0.15), List(0.3, -0.15, 0.)))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 88,
       "text": [
        "DenseTensor2(0.1,-0.2,0.3,-0.2,0.0,-0.15,0.3,-0.15,0.0)"
       ]
      }
     ],
     "prompt_number": 88
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def fobeniusNorm(t: DenseTensor2): Double = {\n",
      "    def averageOverRow(t: DenseTensor2, k: Int): Double = {\n",
      "        // J_ij(k, .) k being a row\n",
      "        val row = for(l <- 0 until t.dim2) yield t(k, l)\n",
      "        row.sum/row.length\n",
      "    }    \n",
      "    def averageOverCol(t: DenseTensor2, l: Int): Double = {\n",
      "        // J_ij(., l) l being a column\n",
      "        val col = for(k <- 0 until t.dim1) yield t(k, l)\n",
      "        col.sum/col.length\n",
      "    }\n",
      "        \n",
      "    val totalAverage: Double = t.sum/t.length\n",
      "    \n",
      "    val transformed: DenseTensor2 = t.copy\n",
      "    for(k <- 0 until w1.dim1; l <- 0 until w1.dim2) {\n",
      "        transformed(k, l) = t(k, l) - averageOverRow(t, k) - averageOverCol(t, l) + totalAv\n",
      "    }\n",
      "    \n",
      "    math.sqrt(transformed.twoNorm)\n",
      "}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      }
     ],
     "prompt_number": 109
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "w1(0, 0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 31,
       "text": [
        "-5.567480802421462"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "w1.map((x) => x*x).sum"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 95,
       "text": [
        "1079.7676571318"
       ]
      }
     ],
     "prompt_number": 95
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "w2.map((x) => x*x).sum"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 94,
       "text": [
        "1084.8894869866033"
       ]
      }
     ],
     "prompt_number": 94
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Next: Calculate frobenius norm and mutual information\n",
      "- exponate? because weight are loglikelihoods\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import cc.factorie.la.Tensor2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      }
     ],
     "prompt_number": 74
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "model.parameters(model.pairwiseFamilies(1, 3).weights)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": []
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": []
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 70,
       "text": [
        "DenseTensor2(-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,0.0,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462,-5.567480802421462)"
       ]
      }
     ],
     "prompt_number": 70
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}