def norris(context):

    # To be more efficient we store intent (as Python set) of every
    # object to the list
    # TODO: Move to Context class?
    examples = []
    for ex in context.examples():
        examples.append(ex)

    cs = [Concept([], context.attributes)]
    for i in range(len(context)):
        # TODO:
        cs_for_loop = cs[:]
        for c in cs_for_loop:
            if c.intent.issubset(examples[i]):
                c.extent.add(context.objects[i])
            else:
                new_intent = c.intent & examples[i]
                new = True
                for j in range(i):
                    if new_intent.issubset(examples[j]) and\
                       context.objects[j] not in c.extent:
                        new = False
                        break
                if new:
                    cs.append(Concept(set([context.objects[i]]) | c.extent,
                        new_intent))
    cs = ConceptSystem(cs)
    return (cs, cs.compute_covering_relation())
Beispiel #2
0
def closeByOne(context):
    alg = CbO(context)
    extent = context.down([])
    intent = context.up(extent)
    concept = Concept(extent, intent)
    alg.generate_from(concept, 0)
    return alg.result
Beispiel #3
0
    def upperNeighbors(self, concept):
        A = concept.extent
        M = set(self._objectsIterator()) - A

        neighbors = set()
        for x in list(M):
            B1 = self.up(A | {x})
            A1 = self.down(B1)
            if (M & ((A1 - A) - {x})) == set():
                neighbors.add(Concept(A1, B1))
            else:
                M = M - {x}
        return neighbors
Beispiel #4
0
    def lowerNeighbors(self, concept):
        B = concept.intent
        M = set(self._attributesIterator()) - B
        neighbors = set()

        for x in list(M):
            A1 = self.down(B | {x})
            B1 = self.up(A1)
            increased = ((B1 - B) - {x})
            if (M & increased) == set():
                neighbors.add(Concept(A1, B1))
            else:
                M = M - {x}
        return neighbors
Beispiel #5
0
    def generate_from(self, concept, y):
        self.result.append(concept)
        A = set(concept.extent)
        B = set(concept.intent)
        n = self.context.width - 1

        if B == set(range(n + 1)) or y > n:
            return

        for j in range(y, n + 1):
            if not (j in B):
                Yj = set(range(j))
                C = A & self.context.down({j})
                D = self.context.up(C)

                if B & Yj == D & Yj:
                    self.generate_from(Concept(C, D), j + 1)
 def getSearchConceptByObjects(self, context, objects):
     sConcept = Concept()
     sConcept.intent = context.up(objects)
     sConcept.extent = context.down(sConcept.intent)
     return sConcept
 def _getSearchConceptByAttr(self, context, attributes):
     sConcept = Concept()
     sConcept.extent = context.down(attributes)
     sConcept.intent = context.up(sConcept.extent)
     return sConcept
	def getSearchConceptByObjects(self, context, objects):
		sConcept = Concept()
		sConcept.intent = context.up(objects)
		sConcept.extent = context.down(sConcept.intent)
		return sConcept
	def _getSearchConceptByAttr(self, context, attributes):
		sConcept = Concept()
		sConcept.extent = context.down(attributes)
		sConcept.intent = context.up(sConcept.extent)
		return sConcept