File contents
#! /usr/bin/env python
# -*- coding: iso-8859-15 -*-
"""Artificial neural networks for Orange.
Orange module to add artificial neural networks as learning
algorithms using calls to SNNS software.
Version: 0.99 (working but leaks memory on every network
training due to importing-unimporting modules
refinements are needed)
SNNS randomness agrees with Orange behaviour on randomness:
http://www.ailab.si/orange/doc/reference/random.htm
In spite of the communicating media with SNNS being files, this code
is supposed to be reentrant. Any way, as some of the temporal files
are named by the module, but created by SNNS, there is a really
extremely small chance of files becoming corrupted and
breaking. Don't worry you would probably win the lotto and hang a
windows program a billion times before this happens.
TO DO:
marked XXX in code,
check removal of all tmp files,
error handling in system calls,
error handling when SNNS fails,
Copyright (C) 2005-2006 Antonio Arauzo Azofra
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
# From std python
import os
import string
import sys
import tempfile
import random
from itertools import izip
# From orange
import orange
import statc
# Should be set to the path where binaries of SNNS tools are
# located, if they are not in system path
pathSNNS = ""
# example:
#pathSNNS = "~/SNNSv4.2/tools/bin/i686-pc-linux-gnu/"
# If messages should be printed
verbose = False
__module_names_freed__ = []
def _argmax(array):
"""
_argmax returns the position of the maximun value of an array
"""
return max(izip(array,xrange(len(array))))[1]
class Transform:
def __init__(self, table, alpha=0.1, beta=0.9):
"""
Prepares transformation of data for neural network
* discrete to N features in {alpha, beta}
* continuous to [alpha, beta]
Details of the transformation performed (transform):
[(Continuous=True, slope, pos),(Continuous=False, no.values)]
y = slope*x + pos
Notes:
Destination is not an orange.Example because we can not use
more than one class feature in Orange
Destination domain is formed by nnAntecedent values followed by
nnTargets (following original order in each subgroup)
"""
self.transform = []
self.alpha = alpha
self.beta = beta
self.domain = table.domain # Previous domain
self.nnAntecedents = 0 # Transformed domain
self.nnTargets = 0
# Prepares transformation of data
basicAttrStat = orange.DomainBasicAttrStat(table)
for i in range( len(table.domain.variables) ):
# Continuous
if self.domain[i].varType == orange.VarTypes.Continuous:
varRange = (basicAttrStat[i].max - basicAttrStat[i].min)
if varRange == 0.0:
slope = 1.0 # Unique value
else:
slope = float(beta-alpha) / varRange
pos = alpha - (slope * basicAttrStat[i].min)
self.transform.append( (True, slope, pos) )
if i != self.domain.variables.index(self.domain.classVar):
self.nnAntecedents += 1
else:
self.nnTargets +=1
# Discrete
else:
nValues = len( self.domain[i].values )
self.transform.append( (False, nValues) )
if i != self.domain.variables.index(self.domain.classVar):
self.nnAntecedents += nValues
else:
self.nnTargets += nValues
def apply(self, example):
"""
Applies a defined trasformation over an example
Returns: a list with the result
"""
rtn = []
# Antecedents
for i in range( len(example) ):
if i != self.domain.variables.index(self.domain.classVar):
# Continuous
if self.transform[i][0]:
if example[i].value in ['?', '~', '.']:
rtn.append(0.5) # NULL values (uses average of [0,1]) XXX
else:
rtn.append( example[i]*self.transform[i][1] + self.transform[i][2] )
# Discrete
else:
for j in range(self.transform[i][1]):
if self.domain[i].values[j] == example[i]:
rtn.append(self.beta)
else:
rtn.append(self.alpha)
# Target (Class or goal attribute)
i = self.domain.variables.index(self.domain.classVar)
# Continuous
if self.transform[i][0]:
if example[i].value in ['?', '~', '.']:
rtn.append(0.5) # NULL values (uses average of [0,1]) XXX
else:
rtn.append( example[i]*self.transform[i][1] + self.transform[i][2] )
# Discrete
else:
for j in range(self.transform[i][1]):
if self.domain[i].values[j] == example[i]:
rtn.append(self.beta)
else:
rtn.append(self.alpha)
return rtn
def applyInverseToTarget(self, target):
"""
From a NN output get the class by: majority criterion, or
denormalizing in continuous cases.
Returns: orange.Value with the class
"""
i = self.domain.variables.index(self.domain.classVar)
if self.transform[i][0]: # continuous
trTarget = (target[0] - self.transform[i][2]) / self.transform[i][1]
rtn = orange.Value(self.domain.classVar, trTarget)
else: # discrete
rtn = orange.Value(self.domain.classVar, _argmax(out) )
#XXX would not be nice if this worked in Orange:
# domain[i].values[_argmax(out)]
return rtn
def __str__(self):
t = '<Transform:\n'
for i in range( len(self.domain.variables) ):
# Continuous
t += self.domain[i].name + str( self.transform[i] ) + '\n'
t += '>\n'
return t
def savePatFile(table):
"""
Given an orange example table create an SNNS pattern file.
Transform data (using Transform):
Normalize continuous data to [0,1].
Discrete values to N inputs/outputs in {0,1}
Caller is responsible for deleting pat file
Returns: (patternFileName, transform)
"""
# Prepares transformation of data
transform = Transform(table, 0.1, 0.9)
# Header
text = "SNNS pattern definition file V1.4\n"
text += "generated at Tue Jan 21 18:02:24 1997\n\n"
text += "No. of patterns : " + str( len(table) ) + '\n'
text += "No. of input units : " + str(transform.nnAntecedents) + '\n'
text += "No. of output units : " + str(transform.nnTargets) + '\n'
fd, patFileName = tempfile.mkstemp(suffix=".pat")
patFile = os.fdopen(fd, "w")
patFile.write(text)
# Examples
for example in table:
text = ""
trEx = transform.apply(example)
for v in trEx:
text += str(v) + ' '
text += "\n"
patFile.write(text)
patFile.close()
return (patFileName, transform)
def createNN(nInputs, hiddenLayers, nOutputs):
"""
Creates a snns file with the topology of a multilayer
completely connected aNN.
Caller is responsible for deleting network file
Returns: name of the file
"""
# Prepare the name of the aNN
hiddenName = ""
for layer in hiddenLayers:
hiddenName += str(layer) + "_"
nnFileNamePrefix = "mlp" + str(nInputs) + "_" + hiddenName + str(nOutputs) + "-"
nnFileName = tempfile.mktemp(prefix=nnFileNamePrefix, suffix=".net")
# Build command for ff_bignet
orden = pathSNNS + "ff_bignet" + " " + "-p " + str(nInputs) + " 1"
for nNodes in hiddenLayers:
orden = orden + " -p " + str(nNodes) + " 1"
orden = orden + " -p " + str(nOutputs) + " 1"
for j in range(len(hiddenLayers)+1):
orden = orden + " -l " + str(j+1) + " + " + str(j+2) + " +"
orden = orden + " " + nnFileName
os.system(orden)
return nnFileName
def trainNN(nnFileName, patternFileName, MSE, cycles, algorithm, learningParams):
"""
Trains a neural network using batchman
"""
# Open tmp file for the script
try:
fd, batchmanScriptFileName = tempfile.mkstemp()
batchmanScriptFile = os.fdopen(fd, 'w')
except IOError:
print 'Error: Couldn\'t create temp file.'
sys.exit(0)
# Create script batchman
nu = 'loadNet("' + nnFileName + '")\n'
nu += 'loadPattern("' + patternFileName + '")\n'
nu += 'setInitFunc("Randomize_Weights", 1.0, -1.0)\n'
nu += 'setLearnFunc("' + algorithm + '"' +\
string.join(["," + p for p in learningParams], sep="") + ')\n'
nu += 'setShuffle(TRUE)\n'
nu += 'initNet()\n'
nu += 'while CYCLES < ' + str(cycles) + ' and MSE > ' + str(MSE) + ' and SIGNAL == 0 do\n'
# nu += 'if CYCLES mod 10 == 0 then\n'
# nu += 'print ("cycles = ", CYCLES, " SSE = ", SSE, " MSE = ",MSE) endif\n'
nu += 'trainNet()\nendwhile\n'
nu += 'if SIGNAL !=0 then print("Stopped due to signal reception: signal " + SIGNAL)\nendif'
nu += '\nsaveNet("'+nnFileName+'")\n'
batchmanScriptFile.write(nu)
batchmanScriptFile.close()
# Train the NN
if verbose:
orden = pathSNNS + "batchman -f " + batchmanScriptFileName
else:
orden = pathSNNS + "batchman -q -f " + batchmanScriptFileName
os.system(orden)
# Remove tmp file
os.remove(batchmanScriptFileName)
def trainAutoNN(nnFileName, trainFileName, testFileName, MSE, cycles, nRepeat, step, algorithm, learningParams):
"""
Trains a neural network using batchman. Uses test data to evaluate
the training state and select the best neural network.
Bad accuracy (not used)
"""
# Open tmp file for the script
try:
fd, batchmanScriptFileName = tempfile.mkstemp()
batchmanScriptFile = os.fdopen(fd, 'w')
except IOError:
print 'Error: Couldn\'t create temp file.'
sys.exit(0)
# Create script batchman
nu = 'net = "' + nnFileName + '"\n'
nu += 'loadNet(net)\n'
nu += 'trainPat = "' + trainFileName + '"\n'
nu += 'testPat = "' + testFileName + '"\n'
nu += 'loadPattern(trainPat)\n'
nu += 'loadPattern(testPat)\n'
nu += 'setInitFunc("Randomize_Weights", 1.0, -1.0)\n'
nu += 'setLearnFunc("' + algorithm + '"' +\
string.join(["," + p for p in learningParams], sep="") + ')\n'
nu += 'setShuffle(TRUE)\n'
nu += 'mejor = 100000000 #Valor grande para representar +infinito\n'
nu += 'for i:=1 to ' + str(nRepeat) + ' do\n'
if verbose:
nu += ' print(" --- ", i)\n'
nu += ' initNet()\n'
nu += ' while CYCLES < ' + str(cycles) + ' and MSE > ' + str(MSE) + ' and SIGNAL == 0 do\n'
nu += ' setPattern(trainPat)\n'
nu += ' for k:= 1 to ' + str(step) + ' do\n'
nu += ' trainNet()\n'
nu += ' endfor\n'
nu += ' setPattern(testPat)\n'
nu += ' testNet()\n'
if verbose:
nu += ' print("MSE =", MSE, "ciclos:", CYCLES)\n'
nu += ' if MSE < mejor then\n'
nu += ' mejor = MSE\n'
nu += ' saveNet(net)\n'
if verbose:
nu += ' print(CYCLES, ": ", MSE, "(mejor MSE)")\n'
nu += ' endif\n'
nu += ' endwhile\n'
nu += 'endfor\n'
if verbose:
nu += 'print("Mejor MSE(", net, ")= ", mejor)\n'
nu += 'if SIGNAL !=0 then print("Stopped due to signal reception: signal " + SIGNAL)\nendif'
batchmanScriptFile.write(nu)
batchmanScriptFile.close()
# Train the NN
if verbose:
orden = pathSNNS + "batchman -f " + batchmanScriptFileName
else:
orden = pathSNNS + "batchman -q -f " + batchmanScriptFileName
os.system(orden)
# Remove tmp file
os.remove(batchmanScriptFileName)
#print "BATCHMAN:", batchmanScriptFileName
def guessTrainParameters(nnFileName, trainFileName, testFileName, MSE, cycles, nRepeat, step, algorithm, learningParams):
"""
By a series of tests choose the number of cycles to train a neural
network.
"""
# Open tmp file for the script
try:
fd, batchmanScriptFileName = tempfile.mkstemp()
batchmanScriptFile = os.fdopen(fd, 'w')
except IOError:
print 'Error: Couldn\'t create temp file.'
sys.exit(0)
# Create script batchman
nu = 'net = "' + nnFileName + '"\n'
nu += 'loadNet(net)\n'
nu += 'trainPat = "' + trainFileName + '"\n'
nu += 'testPat = "' + testFileName + '"\n'
nu += 'loadPattern(trainPat)\n'
nu += 'loadPattern(testPat)\n'
nu += 'setInitFunc("Randomize_Weights", 1.0, -1.0)\n'
nu += 'setLearnFunc("' + algorithm + '"' +\
string.join(["," + p for p in learningParams], sep="") + ')\n'
nu += 'setShuffle(TRUE)\n'
nu += 'for i:=1 to ' + str(nRepeat) + ' do\n'
nu += ' mejor = 100000000 #Valor grande para representar +infinito\n'
nu += ' mejorCycles = 0\n'
nu += ' print(" --- ", i)\n'
nu += ' initNet()\n'
nu += ' while CYCLES < ' + str(cycles) + ' and MSE > ' + str(MSE) + ' and SIGNAL == 0 do\n'
nu += ' setPattern(trainPat)\n'
nu += ' for k:= 1 to ' + str(step) + ' do\n'
nu += ' trainNet()\n'
nu += ' endfor\n'
nu += ' setPattern(testPat)\n'
nu += ' testNet()\n'
nu += ' print("MSE =", MSE, "ciclos:", CYCLES)\n'
nu += ' if MSE < mejor then\n'
nu += ' mejor = MSE\n'
nu += ' mejorCycles = CYCLES\n'
nu += ' print(CYCLES, ": ", MSE, "(mejor MSE)")\n'
nu += ' endif\n'
nu += ' endwhile\n'
nu += ' print("SetCycles=", mejorCycles)\n'
nu += 'endfor\n'
nu += 'print("Mejor MSE(", net, ")= ", mejor)\n'
nu += 'if SIGNAL !=0 then print("Stopped due to signal reception: signal " + SIGNAL)\nendif'
batchmanScriptFile.write(nu)
batchmanScriptFile.close()
# Train the NN
if verbose:
orden = pathSNNS + "batchman -f " + batchmanScriptFileName
else:
orden = pathSNNS + "batchman -q -f " + batchmanScriptFileName
inout = os.popen2(orden)
cycles = []
l = inout[1].readline()
while l:
if l[0:10] == "SetCycles=":
cycles.append( int(l[10:]) )
#print l,
l = inout[1].readline()
if verbose:
print "cycles=", cycles
# Remove tmp file
os.remove(batchmanScriptFileName)
return int( statc.mean(cycles) )
def nn2module(nnFileName, nOutputs):
"""
Creates a new python module with a funcion "eval" that calls the trained
artificial neural network
Caller is responsible for deleting module file and directory.
Returns: the complete pathname of the new module
"""
# Changing False for the commented code solves memory leak but
# introduces errors, as it uses previous modules
if False: #__module_names_freed__:
modulePath, moduleBaseName = __module_names_freed__.pop()
else:
# Creates a tmp directory and module name to create module
modulePath = tempfile.mkdtemp(prefix="oSNNSmod")
moduleBaseName = "tmpOrngSNNSMod" + str( random.randint(0,1000000) )
while moduleBaseName in sys.modules:
moduleBaseName = "tmpOrngSNNSMod" + str( random.randint(0,1000000000000000) )
moduleName = os.path.join(modulePath, moduleBaseName)
# Generates NN C code using SNNS
cFileName = nnFileName.replace(".net", ".c")
if verbose:
orden = pathSNNS + "snns2c " + nnFileName + " " + cFileName + " runNN"
else:
orden = pathSNNS + "snns2c " + nnFileName + " " + cFileName + " runNN &>/dev/null"
os.system(orden)
# Gets NN C code
cFile = open(cFileName)
cCode = cFile.read()
cFile.close()
os.remove(cFileName)
os.remove(cFileName.replace(".c", ".h"))
# Creates python module with NN code
head = "#define NOUTPUTS " + str(nOutputs) + "\n"
head += "#include <Python.h>\n"
pyInterface = """
/* Automatically generated code by OrangeSNNS
This code is by no means an example of good error handling. The messages
printed are aimed to help detecting errors while programming. As these
errors are not supposed posible to happen they are not handled propertly
(no execptions are raised neither program is stopped).
*/
static PyObject *
""" + moduleBaseName + """_eval(PyObject *self, PyObject *args)
{
PyObject * inputs;
int i, l;
float * inputsC = NULL;
float * outputsC = NULL;
PyObject * rtn = NULL;
if (!PyArg_ParseTuple(args, "O", &inputs))
return NULL;
if (!PySequence_Check(inputs))
fprintf(stderr, "Sequence required in call to NN");
else {
l = PySequence_Length(inputs);
inputsC = (float *) malloc( l*sizeof(float) );
if (inputsC != NULL) {
for (i=0; i < l; i++) {
PyObject * f = PySequence_GetItem(inputs, i);
if (!PyFloat_Check(f))
if (!PyInt_Check(f))
fprintf(stderr, "Non-float/int input in call to NN");
else
inputsC[i] = (float) PyInt_AS_LONG(f);
else
inputsC[i] = (float) PyFloat_AsDouble(f);
Py_DECREF(f);
}
l = NOUTPUTS;
outputsC = (float *) malloc( l*sizeof(float) );
if (outputsC != NULL) {
// Call to NN code
runNN(inputsC, outputsC, 0);
rtn = PyTuple_New(l);
if (rtn != NULL) {
for (i=0; i < l; i++) {
PyObject * f = PyFloat_FromDouble( outputsC[i] );
if (f != NULL) {
if ( PyTuple_SetItem(rtn, i, f) )
fprintf(stderr, "Error setting tuple element in NN call");
}
else fprintf(stderr, "Unable to create PyFloat from NN return");
}
}
else fprintf(stderr, "Unable to create tuple calling NN");
}
else fprintf(stderr, "Out of memory calling NN");
}
else fprintf(stderr, "Out of memory calling NN");
}
free(inputsC);
free(outputsC);
return rtn; // Py_BuildValue("i", sts);
}
static PyMethodDef orangeSnnsTmpMethods[] = {
{"eval", """ + moduleBaseName + """_eval, METH_VARARGS,
"Execute a nn."},
{NULL, NULL, 0, NULL} /* Sentinel */
};
PyMODINIT_FUNC
init""" + moduleBaseName + """(void)
{
(void) Py_InitModule(\"""" + moduleBaseName + """\", orangeSnnsTmpMethods);
}
"""
fd, srcFileName = tempfile.mkstemp(prefix="src", suffix=".c")
srcFile = os.fdopen(fd, "w")
srcFile.write(head)
srcFile.write(cCode)
srcFile.write(pyInterface)
srcFile.close()
# Creates setup.py to compile
fd, setupFileName = tempfile.mkstemp(prefix="setup", suffix=".py")
setupFile = os.fdopen(fd, "w")
setupFile.write(
"""
from distutils.core import setup, Extension
module1 = Extension('""" + moduleBaseName + """',
sources = ['""" + srcFileName + """'])
setup (name = 'OrangeSNNStmp',
version = '1.0',
description = 'Function that calls a trained NN',
ext_modules = [module1])
""")
setupFile.close()
# Compile
buildDirTmp = tempfile.mkdtemp()
if buildDirTmp:
if verbose:
os.system("python " + setupFileName + " build -b " + buildDirTmp + \
" install --install-lib " + modulePath)
else:
os.system("python " + setupFileName + " --quiet build -b " + buildDirTmp + \
" install --install-lib " + modulePath)
os.system("rm -r " + buildDirTmp)
os.remove(srcFileName)
os.remove(setupFileName)
return moduleName
# --------------Learner classes (orange integration)------------------
def SNNSLearner(examples=None, **kwds):
learner = SNNSLearner_Class(*(), **kwds)
if examples:
return learner(examples)
else:
return learner
class SNNSLearner_Class:
"""
Artificial Neural Network(ANN) learner class that uses SNNS to
create and train the ANN.
"""
def __init__(self, name='SNNS neural network', hiddenLayers=None,
MSE=0, cycles=200, auto=False, nRepeat=3, step=50,
percentTrain=0.90,
algorithm=None, learningParams=None):
"""
Initializes a new neural network learner, defining the
structure of the networks and training parameters.
By now the structure is a multilayered perceptron
name = learner name
hiddenLayers = a list with the number of nodes of each hidden layer
MSE = stop training if mse is smaller than this value
cycles = stop training after this number of cycles
auto = Whether trainNN (False) or trainAutoNN (True) is used
nRepeat = if auto, the number of times the net is trained
step = if auto, the number of cycles between one test and the next one
percentTrain = if auto, the proportion of patterns used for training
algorithm = name of training algorithm as identified in SNNS
learningParams = list of strings with the parameters as in SNNS
"""
self.name = name
self.hiddenLayers = hiddenLayers
self.MSE = MSE
self.cycles = cycles
self.auto = auto
self.nRepeat = nRepeat
self.step = step
self.percentTrain = percentTrain
if algorithm:
self.algorithm = algorithm
else:
self.algorithm = "Std_Backpropagation"
if learningParams:
self.learningParams = learningParams
else:
self.learningParams = []
def __call__(self, t, weight=None):
patFileName, transform = savePatFile(t)
# If input has no feature with values return a Majority classifier
if transform.nnAntecedents < 1:
return orange.MajorityLearner(t)
if not self.hiddenLayers:
self.hiddenLayers = [ (transform.nnAntecedents + transform.nnTargets)/2 ]
nnFN = createNN(transform.nnAntecedents,
self.hiddenLayers,
transform.nnTargets)
if self.auto:
selection = orange.MakeRandomIndices2(t, self.percentTrain)
trnPatFileName, transform = savePatFile( t.select(selection, 0) )
testPatFileName, ignore = savePatFile( t.select(selection, 1) )
cycles = guessTrainParameters(nnFN, trnPatFileName, testPatFileName,
self.MSE, self.cycles, self.nRepeat, self.step,
self.algorithm, self.learningParams)
else:
cycles = self.cycles
trainNN(nnFN, patFileName, self.MSE, cycles,
self.algorithm, self.learningParams)
moduleName = nn2module(nnFN, transform.nnTargets)
os.remove(patFileName)
os.remove(nnFN)
if self.auto:
os.remove(trnPatFileName)
os.remove(testPatFileName)
# This self.domain seems needed by orgnFSS.FilteredClassifier
# orange bug or misfeature?? XXX report
# domain = t.domain
# Note: -this is used to know which atts are being used by the learner
# -Could be used to check that every example agrees on domain (maybe
# not efficient)
return SNNSClassifier(moduleName, transform=transform, domain = t.domain)
class SNNSClassifier:
def __init__(self, moduleName, transform, name=None, **kwds):
self.__dict__ = kwds
if not name:
self.name="snns"
self.moduleName = moduleName
self.transform = transform
modulePath, moduleBaseName = os.path.split(self.moduleName)
sys.path.insert(0, modulePath)
self.nnModule = __import__(moduleBaseName, globals(), locals())
del sys.path[0]
def __del__(self):
# Free module, it is unimported, beaware!
modulePath, moduleBaseName = os.path.split(self.moduleName)
del sys.modules[moduleBaseName]
del self.nnModule
os.remove(self.moduleName + ".so")
dir, filen = os.path.split(self.moduleName)
os.rmdir(dir)
__module_names_freed__.append( (modulePath, moduleBaseName) )
def __call__(self, exampleOfAnySize, resultType = orange.GetValue):
# Need to perform feature filtering because
# IMHO this should be the duty of orngFSS.FilteredClassifier.__call__
# to achieve transparency of FS in learning methods XXX report
# Workaround to avoid the problem that appears in examples
# with less features:
workaround_domain = orange.Domain([a.name for a in self.transform.domain],
exampleOfAnySize.domain)
example = orange.Example(workaround_domain, exampleOfAnySize)
exTr = self.transform.apply(example)
output = self.nnModule.eval(exTr)
v = self.transform.applyInverseToTarget(output)
if resultType == orange.GetValue:
return v
elif resultType == orange.GetProbabilities:
return output
else:
return (v,output)
# --- main - test ----------------------------------------------
# (Unsorted tests used for development)
def printMemoryUse():
rgc = gc.collect()
f = open("/proc/" + str(os.getpid()) + "/statm")
totalMemorySize = f.readline().split()[0]
f.close()
print "Mem. used:", totalMemorySize, "(gc:", rgc, ")"
if __name__ == "__main__":
import orngTest, orngStat
import gc, os, re, fileinput
import table, table2orange
f = sys.argv[1]
# Get table
if re.match('(.*\.tab)$|(.*\.txt)$', f):
data = orange.ExampleTable(f)
else:
infile = fileinput.input(f)
tt = table.Format().getTableReader().read(infile)
infile.close()
data = table2orange.table2ExampleTable(tt)
snns0 = SNNSLearner(name="snns", cycles=10000)
regresor=snns0(data)
sse = 0.0
print "Results (test)"
for e in data:
print e, "->", regresor(e)
sse += (e['y'] - regresor(e))**2
print "MSE=", sse / len(data)
## for i in range(10):
## printMemoryUse()
## del cl
## cl=snns0(data)
## #cl(data[0])
sys.exit()
snns1 = SNNSLearner(name="snns0.2", auto=True, cycles=100, step=10, learningParams=["0.2"])
snns2 = SNNSLearner(cycles=2000, learningParams=["0.2"])
snns3 = SNNSLearner(cycles=2500, learningParams=["0.2"])
learners = [snns1]#, snns1,snns2,snns3]
## for lp in [ ["0.2"], ["0.1"] ]:
## for cycles in [50]:
## for mode in [True, False]:
## learners.append( SNNSLearner(name="snns"+lp[0]+"-"+str(cycles)+str(mode), auto=mode, cycles=cycles, step=10, learningParams=lp) )
# compute accuracies on data
results = orngTest.crossValidation(learners, data, folds=5)
# Print results
if data.domain.classVar.varType == orange.VarTypes.Continuous:
print "\nLearner MSE SE #Atts SE"
for i in range(len(learners)):
mse, se = complete.MSE_se(results, reportSE=1)[i]
print "%-15s %6.2f %5.3f" % (learners[i].name, mse, se)
else:
print "\nLearner Accuracy SE #Atts SE"
for i in range(len(learners)):
ca, se = orngStat.CA_se(results)[i]
ca, se = ca * 100, se * 100
print "%-15s %6.2f %5.3f" % (learners[i].name, ca, se)
## classifier = snnsLearner(data)
## # compute classification accuracy
## correct = 0.0
## for ex in data:
## if classifier(ex) == ex.getclass():
## correct += 1
## print "Classification accuracy:", correct/len(data)
## for example in t:
## print example,
## print "->", classifier(example)
# Remove the classifier before 'os' module in order to be able to
# delete module file XXX TODO: revise this now it is disabled
# del classifier
Click here to get the file
