def link_connect_impl(self, decided_atoms, new_blended_atom, config_base):
check_type_str = BlendConfig().get_str(self.a, "connect-check-type",
config_base)
strength_diff_threshold = BlendConfig().get_str(
self.a, "connect-strength-diff-limit", config_base)
confidence_above_threshold = BlendConfig().get_str(
self.a, "connect-confidence-above-limit", config_base)
viable_atoms_count_threshold = BlendConfig().get_str(
self.a, "connect-viable-atoms-count-limit", config_base)
self.check_type = get_type(check_type_str)
if check_type_str != get_type_name(self.check_type):
raise UserWarning("Can't resolve type" + str(check_type_str))
try:
self.strength_diff_limit = \
float(strength_diff_threshold)
self.confidence_above_limit = \
float(confidence_above_threshold)
except (TypeError, ValueError):
raise UserWarning(
"Can't parse threshold value:: "
"{strength: {0}, confidence: {1}, count: {2}}".format(
str(strength_diff_threshold),
str(confidence_above_threshold),
str(viable_atoms_count_threshold)))
try:
self.viable_atoms_count_threshold = \
int(viable_atoms_count_threshold)
except ValueError:
self.viable_atoms_count_threshold = None
self.__connect_links_simple(decided_atoms, new_blended_atom)
def _get_atoms_by_type(self, type):
type_name = get_type_name(type)
return execute_atom(
self.space,
GetLink(
VariableList(
TypedVariableLink(VariableNode("X"), TypeNode(type_name))),
AndLink(VariableNode("X"))))
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
name = "InversionRule<%s>"%(get_type_name(link_type),),
outputs=[chainer.link(link_type, [B, A])],
inputs=[chainer.link(link_type, [A, B]), A, B],
formula=formulas.inversionFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
name="SymmetricModusPonensRule<%s>"%(get_type_name(link_type),),
outputs=[B],
inputs=[chainer.link(link_type, [A, B]),
A],
formula=formulas.symmetricModusPonensFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
name="AndToSubsetRule1<%s>"%(get_type_name(link_type),),
outputs=[chainer.link(link_type, [A, B])],
inputs=[chainer.link(types.AndLink, [A, B]),
A],
formula=formulas.subsetFormula)
def vertices_from_atomset(atomset):
"""
Converts an atomset representing a subhypergraph into a set of vertices
representing a graph
"""
vertices = []
for atom in atomset:
vertex = {"type": get_type_name(atom.type), "name": atom.name, "handle": atom.h.value()}
vertices.append(vertex)
return vertices
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
Rule.__init__(self,
name="DeductionGeometryRule<%s>"%(get_type_name(link_type),),
formula=formulas.deductionGeometryFormula,
outputs=[chainer.link(link_type, [A, C])],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C])])
def __init__(self, chainer, link_type1, link_type2, *args):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
# compositions can encompass either 1, 3, 5, 9 or 13 relations
outputs = []
for output_type in args:
outputs.append(chainer.link(output_type, [A, C]))
Rule.__init__(self,
name="TemporalCompositionRule ({0}).({1}) = ({2})"
.format(
get_type_name(link_type1),
get_type_name(link_type2),
" ".join([get_type_name(output_type)
for output_type in args])),
# a formula is still needed
formula=None,
inputs=[chainer.link(link_type1, [A, B]),
chainer.link(link_type2, [B, C])],
outputs=outputs)
def __init__(self, chainer, link_type):
S = chainer.new_variable()
M = chainer.new_variable()
L = chainer.new_variable()
Rule.__init__(self,
name="AbductionRule<%s>"%(get_type_name(link_type),),
outputs=[chainer.link(link_type, [S, L])],
inputs=[chainer.link(link_type, [S, M]),
chainer.link(link_type, [L, M]), S, M, L],
formula=formulas.abductionFormula)
def __init__(self, chainer, link_type1, link_type2, *args):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
# compositions can encompass either 1, 3, 5, 9 or 13 relations
outputs = []
for output_type in args:
outputs.append(chainer.link(output_type, [A, C]))
Rule.__init__(self,
name="TemporalCompositionRule ({0}).({1}) = ({2})"
.format(
get_type_name(link_type1),
get_type_name(link_type2),
" ".join([get_type_name(output_type)
for output_type in args])),
# a formula is still needed
formula=None,
inputs=[chainer.link(link_type1, [A, B]),
chainer.link(link_type2, [B, C])],
outputs=outputs)
def __init__(self, chainer, link_type, formula= formulas.deductionSimpleFormula):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
Rule.__init__(self, formula=formula,
outputs= [chainer.link(link_type, [A, C])],
inputs= [chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C])]
)
self.name = get_type_name(link_type) + 'TransitivityRule'
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
Rule.__init__(self,
name="TransitiveSimilarityRule<%s>"%(get_type_name(link_type),),
formula=formulas.transitiveSimilarityFormula,
outputs=[chainer.link(link_type, [A, C])],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C]),
A, B, C])
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
AB = chainer.link(link_type, [A, B])
BA = chainer.link(link_type, [B, A])
Rule.__init__(self,
name="TermProbabilityRule<%s>"%(get_type_name(link_type),),
outputs=[B],
inputs=[AB, BA, A],
formula=formulas.termProbabilityFormula)
def __init__(self, chainer, link_type, formula= formulas.deductionIndependenceBasedFormula):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
Rule.__init__(self, formula=formula,
outputs= [chainer.link(link_type, [A, C])],
inputs= [chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C])]
)
self.name = get_type_name(link_type) + 'TransitivityRule'
def __init__(self, chainer, link_type, N):
vars = chainer.make_n_variables(N)
lhs = chainer.link(types.AndLink, vars[:-1])
rhs = vars[-1]
Rule.__init__(self,
name="AndToSubsetRuleN<%s,%s>"%(get_type_name(link_type),N),
outputs=[chainer.link(link_type, [lhs, rhs])],
inputs=[chainer.link(types.AndLink, vars),
lhs],
formula=formulas.subsetFormula)
def __init__(self, chainer, link_type, formula):
A = chainer.new_variable()
B = chainer.new_variable()
ta = chainer.new_variable()
tb = chainer.new_variable()
Rule.__init__(self,
formula= formula,
outputs= [chainer.link(link_type, [A, B])],
inputs= [chainer.link(types.AtTimeLink, [ta, A]),
chainer.link(types.AtTimeLink, [tb, B])])
self.name = get_type_name(link_type) + 'EvaluationRule'
def __init__(self, chainer, link_type, formula):
A = chainer.new_variable()
B = chainer.new_variable()
ta = chainer.new_variable()
tb = chainer.new_variable()
Rule.__init__(self,
formula= formula,
outputs= [chainer.link(link_type, [A, B])],
inputs= [chainer.link(types.AtTimeLink, [ta, A]),
chainer.link(types.AtTimeLink, [tb, B])])
self.name = get_type_name(link_type) + 'EvaluationRule'
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
notA = chainer.link(types.NotLink, [A])
Rule.__init__(self,
name="PreciseModusPonensRule<%s>"%(get_type_name(link_type),),
outputs=[B],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [notA, B]),
A],
formula=formulas.preciseModusPonensFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
AndAB = chainer.link(types.AndLink, [A, B])
Rule.__init__(self,
name="AndAs1stArgInsideLinkRule<%s>"
%(get_type_name(link_type)),
inputs=[C, chainer.link(link_type, [A, C]),
chainer.link(link_type, [B, C]), A, B],
outputs=[chainer.link(link_type, [AndAB, C]),
AndAB],
formula=formulas.andAs1stArgInsideLinkFormula)
def __init__(self, chainer, N, link_type=None):
self._chainer = chainer
if link_type is not None:
atoms = [chainer.link(link_type, chainer.make_n_variables(2)) for i in range(N)]
else:
atoms = chainer.make_n_variables(N)
Rule.__init__(self,
formula=formulas.andFormula,
outputs=[chainer.link(types.AndLink, atoms)],
inputs=atoms,
name = "AndCreationRule<"+str(N) +
"%s>"%("" if link_type is None else ", " + get_type_name(link_type)))
def __init__(self, chainer, link_type, formula= formulas.deductionIndependenceBasedFormula):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
rules.Rule.__init__(self, formula=formula,
outputs= [chainer.link(link_type, [A, C])],
inputs= [chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C])]
)
self.name = get_type_name(link_type) + 'TransitivityRule'
self.probabilistic_inputs = False
def vertices_from_atomset(atomset):
"""
Converts an atomset representing a subhypergraph into a set of vertices
representing a graph
"""
vertices = []
for atom in atomset:
vertex = {
'type': get_type_name(atom.type),
'name': atom.name,
'handle': atom.h.value()
}
vertices.append(vertex)
return vertices
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_varialbe()
C = chainer.new_variable()
AndBC = chainer.link(types.AndLink, [B, C])
Rule.__init__(self,
name="AndAs2ndArgInsideLinkRule<%s>"
%(get_type_name(link_type)),
inputs=[chainer.link(types.InheritanceLink, [A, B]),
chainer.link(types.InheritanceLink, [A, C]),
A, B, C],
outputs=[chainer.link(types.InheritanceLink, [A, AndBC]),
AndBC],
formula=formulas.andAs2ndArgInsideLinkFormula)
def __init__(self, chainer, link_type, formula):
A = chainer.new_variable()
B = chainer.new_variable()
ta = chainer.new_variable()
tb = chainer.new_variable()
Rule.__init__(self,
formula=formula,
outputs=[chainer.link(link_type, [A, B])],
inputs=[
chainer.link(types.AtTimeLink, [A, ta]),
chainer.link(types.AtTimeLink, [B, tb])
])
self.name = get_type_name(link_type) + 'EvaluationRule'
self.probabilistic_inputs = False
#! /usr/bin/env python
#
# atom_type_names.py
#
"""
Example of how to obtain atom type names and atom type IDs in Python
"""
__author__ = 'Cosmo Harrigan'
from opencog.atomspace import AtomSpace, types, get_type_name
atomspace = AtomSpace()
atom = atomspace.add(types.ConceptNode, "Frog #1")
# To get one type name
print get_type_name(3) + '\n'
# To get one atom's type name
print get_type_name(atom.type) + '\n'
# Get a list of all possible type names and numbers
for key, value in sorted(types.__dict__.iteritems()):
if '__' not in key:
print key, value
def test_get_type_name(self):
self.assertEqual(get_type_name(types.Node), "Node")
self.assertEqual(get_type_name(2231), "")
self.assertEqual(get_type_name(types.NO_TYPE), "")
def test_get_type_name(self):
self.assertEqual(get_type_name(types.Node), "Node")
self.assertEqual(get_type_name(2231), "")
self.assertEqual(get_type_name(types.NO_TYPE), "")
#
"""
Example of how to obtain atom type names and atom type IDs in Python
"""
__author__ = 'Cosmo Harrigan'
from opencog.atomspace import AtomSpace, TruthValue, types, get_type_name
from opencog.scheme_wrapper import load_scm, scheme_eval, scheme_eval_h, __init__
atomspace = AtomSpace()
__init__(atomspace)
data = ["opencog/atomspace/core_types.scm", "opencog/scm/utilities.scm"]
for item in data:
load_scm(atomspace, item)
atom = atomspace.add(types.ConceptNode, "Frog #1")
# To get one type name
print get_type_name(3) + '\n'
# To get one atom's type name
print get_type_name(atom.type) + '\n'
# Get a list of all possible type names and numbers
for key, value in sorted(types.__dict__.iteritems()):
if '__' not in key:
print key, value
def test_get_type_name(self):
self.assertEqual(get_type_name(types.Node), "Node")
self.assertEqual(get_type_name(2231), "")
# XXX FIXME is testing the name of the bottom type
# a sane thing to do?
self.assertEqual(get_type_name(types.NO_TYPE), "*** Bottom Type! ***")
#! /usr/bin/env python
#
# atom_type_names.py
#
"""
Example of how to obtain atom type names and atom type IDs in Python
"""
__author__ = 'Cosmo Harrigan'
from opencog.atomspace import AtomSpace, types, get_type_name
atomspace = AtomSpace()
atom = atomspace.add(types.ConceptNode, "Frog #1")
# To get one type name
print(get_type_name(3) + '\n')
# To get one atom's type name
print(get_type_name(atom.type) + '\n')
# Get a list of all possible type names and numbers
for key, value in sorted(types.__dict__.items()):
if '__' not in key:
print(key, value)
