pythoncard-cvs

[Kevin A. <ka...@us...>]

Update of /cvsroot/pythoncard/PythonCard/samples/iacGrid
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv25741

Added Files:
	.cvsignore iac.py iac.pyc iacGrid.py iacGrid.rsrc.py jets.txt 
	readme.txt 
Log Message:
added iacGrid (probably needs a better name)


--- NEW FILE: .cvsignore ---
.cvsignore
*.pyc
*.log
.DS_Store

--- NEW FILE: iacGrid.rsrc.py ---

{ 'application':{ 'type':'Application',
            'name':'SimpleGrid',

    'backgrounds':
 [ 
  { 'type':'Background',
    'name':'bgMin',
    'title':'Simple Grid PythonCard Application',
    'size':( 600, 400 ),
    'style':['resizeable'],

    'menubar': 
    { 
        'type':'MenuBar',
        'menus': 
        [
            { 'type':'Menu',
              'name':'menuFile',
              'label':'&File',
              'items': [ 
                { 'type':'MenuItem',
                  'name':'menuFileExit',
                  'label':'E&xit\tAlt+X',
                  'command':'exit' } ] }
        ]       
    },

   'components':
   [ 
    { 'type':'Grid',
      'name':'mygrid',
      'position':(0, 0),
      'size':(400, 300),
    },
   ]
  }
 ]
 }
 }


--- NEW FILE: iac.pyc ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: iacGrid.py ---
#!/usr/bin/python

"""
__version__ = "$Revision: 1.1 $"
__date__ = "$Date: 2006/07/28 03:01:16 $"
"""

from PythonCard import dialog, model
import wx
from wx import grid
import sys

import iac

def colormap(intensity):
    if intensity < .03:
        return "white"
    g = int(255.99 * intensity)
    return (255, g, 0)

class Minimal(model.Background):

    def on_initialize(self, event):
        self.log = sys.stdout
        self.moveTo = None

##        wx.EVT_IDLE(self, self.OnIdle)
        
        self.mygrid = mygrid = self.components.mygrid

        mygrid.CreateGrid(30, 25) #, wxGrid.wxGridSelectRows)
        ##mygrid.EnableEditing(False)

        """
        # simple cell formatting
        mygrid.SetColSize(3, 200)
        mygrid.SetRowSize(4, 45)
        mygrid.SetCellValue(0, 0, "First cell")
        mygrid.SetCellValue(1, 1, "Another cell")
        mygrid.SetCellValue(2, 2, "Yet another cell")
        mygrid.SetCellValue(3, 3, "This cell is read-only")
        mygrid.SetCellFont(0, 0, wx.Font(12, wx.ROMAN, wx.ITALIC, wx.NORMAL))
        mygrid.SetCellTextColour(1, 1, wx.RED)
        mygrid.SetCellBackgroundColour(2, 2, wx.CYAN)
        mygrid.SetReadOnly(3, 3, True)

        mygrid.SetCellEditor(5, 0, grid.GridCellNumberEditor(1,1000))
        mygrid.SetCellValue(5, 0, "123")
        mygrid.SetCellEditor(6, 0, grid.GridCellFloatEditor())
        mygrid.SetCellValue(6, 0, "123.34")
        mygrid.SetCellEditor(7, 0, grid.GridCellNumberEditor())

        mygrid.SetCellValue(6, 3, "You can veto editing this cell")


        # attribute objects let you keep a set of formatting values
        # in one spot, and reuse them if needed
        attr = grid.GridCellAttr()
        attr.SetTextColour(wx.BLACK)
        attr.SetBackgroundColour(wx.RED)
        attr.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        # you can set cell attributes for the whole row (or column)
        mygrid.SetRowAttr(5, attr)

        mygrid.SetColLabelValue(0, "Custom")
        mygrid.SetColLabelValue(1, "column")
        mygrid.SetColLabelValue(2, "labels")

        mygrid.SetColLabelAlignment(wx.ALIGN_LEFT, wx.ALIGN_BOTTOM)

        #mygrid.SetDefaultCellOverflow(False)
        #r = wx.GridCellAutoWrapStringRenderer()
        #mygrid.SetCellRenderer(9, 1, r)

        # overflow cells
        mygrid.SetCellValue( 9, 1, "This default cell will overflow into neighboring cells, but not if you turn overflow off.");
        mygrid.SetCellSize(11, 1, 3, 3);
        mygrid.SetCellAlignment(11, 1, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE);
        mygrid.SetCellValue(11, 1, "This cell is set to span 3 rows and 3 columns");
        """
        
        self.populate_cells_from_file()

        sizer1 = wx.BoxSizer(wx.VERTICAL)
        sizer1.Add(self.components.mygrid, 1, wx.EXPAND)
        
        sizer1.Fit(self)
        sizer1.SetSizeHints(self)
        self.panel.SetSizer(sizer1)
        self.panel.SetAutoLayout(1)
        self.panel.Layout()

    def populate_cells_from_file(self, filename='jets.txt'):
        iac.load(filename)
        mygrid = self.mygrid
        for row, line in enumerate(open(filename)):
            fields = line.rstrip().split()
            for col, value in enumerate(fields):
                print row, col, value
                mygrid.SetCellValue(row, col, value)
        self.rowcnt = row + 1
        self.colcnt = col + 1
        print self.rowcnt, self.colcnt


##    def OnCellLeftClick(self, event):
    def on_mygrid_mouseClick(self, event):
        self.log.write("mouseClick: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()

    def on_mygrid_mouseContextClick(self, event):
        self.log.write("mouseContextClick: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()

    def on_mygrid_mouseDoubleClick(self, event):
        self.log.write("mouseDoubleClick: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()

    def on_mygrid_mouseContextDoubleClick(self, event):
        self.log.write("mouseContextDoubleClick: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()

    def on_mygrid_labelClick(self, event):
        self.log.write("labelClick: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()

    def on_mygrid_labelContextClick(self, event):
        self.log.write("labelContextClick: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()

    def on_mygrid_labelDoubleClick(self, event):
        self.log.write("labelDoubleClick: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()

    def on_mygrid_labelContextDoubleClick(self, event):
        self.log.write("labelContextDoubleClick: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()


    def on_mygrid_rowSize(self, event):
        self.log.write("rowSize: row %d, %s\n" %
                       (event.GetRowOrCol(), event.position))
        event.skip()

    def on_mygrid_columnSize(self, event):
        self.log.write("columnSize: col %d, %s\n" %
                       (event.GetRowOrCol(), event.position))
        event.skip()

    def on_mygrid_rangeSelect(self, event):
        if event.Selecting():
            self.log.write("rangeSelect: top-left %s, bottom-right %s\n" %
                           (event.GetTopLeftCoords(), event.GetBottomRightCoords()))
        tl = r1, c1 = event.GetTopLeftCoords()
        br = r2, c2 = event.GetBottomRightCoords()
        result = []
        if r1 == r2:
            for col in range(c1, c2+1):
                result.append(self.mygrid.GetCellValue(r1, col))
        elif c1 == c2:
            for row in range(r1, r2+1):
                result.append(self.mygrid.GetCellValue(row, c1))
        else:
            for row in range(r1, r2+1):
                for col in range(c1, c2+1):
                    result.append(self.mygrid.GetCellValue(row, col))
        iac.reset()
        print 'Touching', ' '.join(result)
        iac.touch(' '.join(result), 1.0)
        response = iac.run()
        mygrid = self.mygrid
        rowcnt, colcnt = self.rowcnt, self.colcnt
        for r in xrange(rowcnt):
            for c in xrange(colcnt):
                neuron = mygrid.GetCellValue(r, c)
                intensity = max(0, response.get(neuron, 0))
                color = colormap(intensity)
                mygrid.SetCellBackgroundColour(r, c, color)
        
        # force refresh
        mygrid.Refresh()
        mygrid.Update()

        event.skip()


    def on_mygrid_cellChange(self, event):
        self.log.write("cellChange: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))

        # Show how to stay in a cell that has bad data.  We can't just
        # call SetGridCursor here since we are nested inside one so it
        # won't have any effect.  Instead, set coordinants to move to in
        # idle time.
        value = self.components.mygrid.GetCellValue(event.row, event.column)
        if value == 'no good':
            self.moveTo = event.row, event.column


    def on_idle(self, event):
        if self.moveTo != None:
            self.components.mygrid.SetGridCursor(self.moveTo[0], self.moveTo[1])
            self.moveTo = None
        event.skip()


    def on_mygrid_selectCell(self, event):
        self.log.write("selectCell: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))

        # Another way to stay in a cell that has a bad value...
        mygrid = self.components.mygrid
        row = mygrid.GetGridCursorRow()
        col = mygrid.GetGridCursorCol()
        if mygrid.IsCellEditControlEnabled():
            mygrid.HideCellEditControl()
            mygrid.DisableCellEditControl()
        value = mygrid.GetCellValue(row, col)
        if value == 'no good 2':
            return  # cancels the cell selection
        event.skip()


    def on_mygrid_editorShown(self, event):
        if event.row == 6 and event.column == 3:
            result = dialog.messageDialog(self, "Are you sure you wish to edit this cell?",
                        "Checking", wx.YES_NO)
            if not result.accepted:
                event.Veto()
                return

        self.log.write("editorShown: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()


    def on_mygrid_editorHidden(self, event):
        if event.row == 6 and event.column == 3:
            result = dialog.messageDialog(self, "Are you sure you wish to finish editing this cell?",
                        "Checking", wx.YES_NO)
            if not result.accepted:
                event.Veto()
                return

        self.log.write("on_mygrid_editorHidden: (%d,%d) %s\n" %
                       (event.row, event.column, event.position))
        event.skip()


    def on_mygrid_editorCreated(self, event):
        self.log.write("on_mygrid_editorCreated: (%d, %d) %s\n" %
                       (event.row, event.column, event.GetControl()))


if __name__ == '__main__':
    app = model.Application(Minimal)
    app.MainLoop()

--- NEW FILE: readme.txt ---
The example is taken from Parallel Distributed Processing, a classic text on neural networks.

The field values represent neurons.

The database rows represent excitory connections.

The database columns represent inhibitory connections.

The network is probed by applying a stimulus to a set of neurons.

The output is a sorted list of neurons and their activation levels.

The network can generalize from small datasets and is resiliant when information is missing.

http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496908


The grid code was derived from the simpleGrid sample.

--- NEW FILE: jets.txt ---
Art         Jets        40      jh      sing    pusher
Al          Jets        30      jh      mar     burglar
Sam         Jets        20      col     sing    bookie
Clyde       Jets        40      jh      sing    bookie
Mike        Jets        30      jh      sing    bookie
Jim         Jets        20      jh      div     burglar
Greg        Jets        20      hs      mar     pusher
John        Jets        20      jh      mar     burglar
Doug        Jets        30      hs      sing    bookie
Lance       Jets        20      jh      mar     burglar
George      Jets        20      jh      div     burglar
Pete        Jets        20      hs      sing    bookie
Fred        Jets        20      hs      sing    pusher
Gene        Jets        20      col     sing    pusher
Ralph       Jets        30      jh      sing    pusher

Phil        Sharks      30      col     mar     pusher
Ike         Sharks      30      jh      sing    bookie
Nick        Sharks      30      hs      sing    pusher
Don         Sharks      30      col     mar     burglar
Ned         Sharks      30      col     mar     bookie
Karl        Sharks      40      hs      mar     bookie
Ken         Sharks      20      hs      sing    burglar
Earl        Sharks      40      hs      mar     burglar
Rick        Sharks      30      hs      div     burglar
Ol          Sharks      30      col     mar     pusher
Neal        Sharks      30      hs      sing    bookie
Dave        Sharks      30      hs      div     pusher

--- NEW FILE: iac.py ---

"""
__version__ = "$Revision: 1.1 $"
__date__ = "$Date: 2006/07/28 03:01:16 $"
"""

"""
based on http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496908
#modified to work with Python 2.3

Data Mining with Neural Nets 
Raymond Hettinger
Apply the IAC (interactive-competition-and-activation) model to analyzing a database.
"""


# Constants defining the neuron's response curve

minact, rest, thresh, decay, maxact = -0.2, -0.1, 0.0, 0.1, 1.0
alpha, gamma, estr = 0.1, 0.1, 0.4

units = []
pools = []
unitbyname = {}

def sorted(s, reverse=False):
    s = list(s)
    s.sort()
    if reverse:
        s.reverse()
    return s

from sets import Set as set

class Unit(object):
    __slots__ = ['name', 'pool', 'extinp', 'activation', 'output', 'exciters', 'newact']
    def __init__(self, name, pool):
        self.name = name
        self.pool = pool
        self.reset()
        self.exciters = []
        unitbyname[name] = self
    def reset(self):
        self.setext(0.0)
        self._setactivation()
    def setext(self, weight=1.0):
        self.extinp = weight
    def _setactivation(self, val=rest):
        self.activation = val
        self.output = max(thresh, val)
    def addexciter(self, aunit):
        self.exciters.append(aunit)
    def remove(self, aunit):
        self.exciters.remove(aunit)
    def computenewact(self):
        ai = self.activation
        plus = sum([exciter.output for exciter in self.exciters])
        minus = self.pool.sum - self.output
        netinput = alpha*plus - gamma*minus + estr*self.extinp
        if netinput > 0:
            ai = (maxact-ai)*netinput - decay*(ai-rest) + ai
        else:
            ai = (ai-minact)*netinput - decay*(ai-rest) + ai
        self.newact = max(min(ai, maxact), minact)
    def commitnewact(self):
        self._setactivation(self.newact)

class Pool(object):
    __slots__ = ['sum', 'members']
    def __init__(self):
        self.sum = 0.0
        self.members = set()
    def addmember(self, member):
        self.members.add(member)
    def updatesum(self):
        self.sum = sum([member.output for member in self.members])
    def display(self):
        result = sorted([(unit.activation, unit.name) for unit in self.members], reverse=True)
        for i, (act, unitbyname) in enumerate(result):
            print '%s: %.2f\t' % (unitbyname, act),
            if i % 4 == 3: print
        print '\n'
    def getpooldict(self):
        return dict([(unit.name, unit.activation) for unit in self.members])


def load(filename):
    """Load in a database and interpret it as a network

    First column must be unique keys which define the instance units.
    Each column is a pool (names, gangs, ages, etc).
    Every row is mutually excitory.
    """
    units[:] = []
    pools[:] = []
    for line in open(filename):
        relatedunits = line.split()
        if not len(relatedunits): continue
        key = len(units)
        for poolnum, name in enumerate(relatedunits):
            if poolnum >= len(pools):
                pools.append(Pool())
            pool = pools[poolnum]
            if name in unitbyname:
                unit = unitbyname[name]
            else:
                unit = Unit(name, pool)
                units.append(unit)
            pool.addmember(unit)
            if poolnum > 0:
                units[key].addexciter(unit)
                unit.addexciter(units[key])

def reset():
    for unit in units:
        unit.reset()

def depair(i, j):
    unitbyname[i].remove(unitbyname[j])
    unitbyname[j].remove(unitbyname[i])

def touch(itemstr, weight=1.0):
    for name in itemstr.split():
        unitbyname[name].setext(weight)

def run(times=100):
    """Run n-cycles and display result"""
    for i in xrange(times):
        for pool in pools:
            pool.updatesum()
        for unit in units:
            unit.computenewact()
        for unit in units:
            unit.commitnewact()
    print '-' * 20
    for pool in pools:
        pool.display()
    d = {}
    for pool in pools:
        d.update(pool.getpooldict())
    print d
    return d