147 lines
5.0 KiB
Python
147 lines
5.0 KiB
Python
import math #, random
|
|
import logging
|
|
|
|
import utils
|
|
|
|
from temperature import temperature
|
|
|
|
actualTemperature = Temperature = 100.0
|
|
|
|
def selectListPosition(probabilities):
|
|
total = sum(probabilities)
|
|
#logging.info('total: %s' % total)
|
|
r = utils.random()
|
|
stopPosition = total * r
|
|
#logging.info('stopPosition: %s' % stopPosition)
|
|
total = 0
|
|
index = 0
|
|
for probability in probabilities:
|
|
total += probability
|
|
if total > stopPosition:
|
|
return index
|
|
index += 1
|
|
return 0
|
|
|
|
def weightedAverage(values):
|
|
total = 0.0
|
|
totalWeights = 0.0
|
|
for value,weight in values:
|
|
total += value * weight
|
|
totalWeights += weight
|
|
if not totalWeights:
|
|
return 0.0
|
|
return total / totalWeights
|
|
|
|
def temperatureAdjustedValue(value):
|
|
#logging.info('Temperature: %s' % Temperature)
|
|
#logging.info('actualTemperature: %s' % actualTemperature)
|
|
return value ** (((100.0-Temperature)/30.0)+0.5)
|
|
|
|
def temperatureAdjustedProbability(value):
|
|
if not value or value == 0.5 or not temperature.value:
|
|
return value
|
|
if value < 0.5:
|
|
return 1.0 - temperatureAdjustedProbability(1.0 - value)
|
|
coldness = 100.0 - temperature.value
|
|
a = math.sqrt(coldness)
|
|
b = 10.0 - a
|
|
c = b / 100
|
|
d = c * ( 1.0 - ( 1.0 - value ) ) # aka c * value, but we're following the java
|
|
e = ( 1.0 - value ) + d
|
|
f = 1.0 - e
|
|
return max(f,0.5)
|
|
|
|
def coinFlip(chance=0.5):
|
|
return utils.random() < chance
|
|
|
|
def blur(value):
|
|
root = math.sqrt(value)
|
|
if coinFlip():
|
|
return value + root
|
|
return value - root
|
|
|
|
def chooseObjectFromList(objects,attribute):
|
|
if not objects:
|
|
return None
|
|
probabilities = []
|
|
for object in objects:
|
|
value = getattr(object,attribute)
|
|
probability = temperatureAdjustedValue(value)
|
|
logging.info('Object: %s, value: %d, probability: %d' % (object,value,probability))
|
|
probabilities += [ probability ]
|
|
index = selectListPosition(probabilities)
|
|
logging.info("Selected: %d" % index)
|
|
return objects[index]
|
|
|
|
def chooseRelevantDescriptionByActivation(workspaceObject):
|
|
descriptions = workspaceObject.relevantDescriptions()
|
|
if not descriptions:
|
|
return None
|
|
activations = [ description.descriptor.activation for description in descriptions ]
|
|
index = selectListPosition(activations)
|
|
return descriptions[ index ]
|
|
|
|
def similarPropertyLinks(slip_node):
|
|
result = []
|
|
for slip_link in slip_node.propertyLinks:
|
|
association = slip_link.degreeOfAssociation() / 100.0
|
|
probability = temperatureAdjustedProbability( association )
|
|
if coinFlip(probability):
|
|
result += [ slip_link ]
|
|
return result
|
|
|
|
def chooseSlipnodeByConceptualDepth(slip_nodes):
|
|
if not slip_nodes:
|
|
return None
|
|
depths = [ temperatureAdjustedValue(n.conceptualDepth) for n in slip_nodes ]
|
|
i = selectListPosition(depths)
|
|
return slip_nodes[ i ]
|
|
|
|
def __relevantCategory(objekt,slipnode):
|
|
return objekt.rightBond and objekt.rightBond.category == slipnode
|
|
|
|
def __relevantDirection(objekt,slipnode):
|
|
return objekt.rightBond and objekt.rightBond.directionCategory == slipnode
|
|
|
|
def __localRelevance(string,slipnode,relevance):
|
|
numberOfObjectsNotSpanning = numberOfMatches = 0.0
|
|
#logging.info("find relevance for a string: %s" % string);
|
|
for objekt in string.objects:
|
|
#logging.info('object: %s' % objekt)
|
|
if not objekt.spansString():
|
|
#logging.info('non spanner: %s' % objekt)
|
|
numberOfObjectsNotSpanning += 1.0
|
|
if relevance(objekt,slipnode):
|
|
numberOfMatches += 1.0
|
|
#logging.info("matches: %d, not spanning: %d" % (numberOfMatches,numberOfObjectsNotSpanning))
|
|
if numberOfObjectsNotSpanning == 1:
|
|
return 100.0 * numberOfMatches
|
|
return 100.0 * numberOfMatches / (numberOfObjectsNotSpanning - 1.0)
|
|
|
|
def localBondCategoryRelevance(string, category):
|
|
if len(string.objects) == 1:
|
|
return 0.0
|
|
return __localRelevance(string,category,__relevantCategory)
|
|
|
|
def localDirectionCategoryRelevance(string, direction):
|
|
return __localRelevance(string,direction,__relevantDirection)
|
|
|
|
def getMappings(objectFromInitial,objectFromTarget, initialDescriptions, targetDescriptions):
|
|
mappings = []
|
|
from conceptMapping import ConceptMapping
|
|
for initialDescription in initialDescriptions:
|
|
for targetDescription in targetDescriptions:
|
|
if initialDescription.descriptionType == targetDescription.descriptionType:
|
|
if initialDescription.descriptor == targetDescription.descriptor or initialDescription.descriptor.slipLinked(targetDescription.descriptor):
|
|
mapping = ConceptMapping(
|
|
initialDescription.descriptionType,
|
|
targetDescription.descriptionType,
|
|
initialDescription.descriptor,
|
|
targetDescription.descriptor,
|
|
objectFromInitial,
|
|
objectFromTarget
|
|
)
|
|
mappings += [ mapping ]
|
|
return mappings
|
|
|