Ayurvedic Classification as a Rule-Based Expert System

#!/usr/bin/env python3
"""Ayurvedic classification as a rule-based expert system. MU's topic 4.

 THIS IS NOT MEDICAL SOFTWARE AND IT IS NOT MEDICAL ADVICE. It is a
knowledge-representation exercise on a classical text, which is what MU's
syllabus asks for. Nothing here says a classical rule is clinically correct.

IKS concept as CS concept: the tridosa attribute lists of Charaka Samhita,
Sutrasthana I.58 to I.60, as a feature space; the classification of a
description into wind, bile or phlegm as multi-class classification; and
Charaka's own rule of the adverse attribute as an IF-THEN rule with an
explanation.

 THE TABLE IS QUOTED, NOT INVENTED. It is read off Avinash Chandra
Kaviratna's translation:
  I.58  "Wind, which may be dry, cold, light, subtile, unstable, clear, keen,
         is cured by objects which have adverse attributes."
  I.59  "Bile, which may be cold, hot, keen, soft, sour, liquid, and bitter,
         is speedily cured by objects having adverse attributes."
  I.60  "Heavy, cold, mild, watery, sweet, stable, and slimy, these attributes
         of phlegm are cured by objects having adverse attributes."

 I.59 prints BOTH "cold" and "hot" for the same dosa, which cannot both be
intended. The table below records the line as printed and DISPUTED holds the
attribute the book refuses to rely on. FINDINGS section 3.
"""
import math

ATTRIBUTES = {
    'wind':   ['dry', 'cold', 'light', 'subtile', 'unstable', 'clear', 'keen'],
    'bile':   ['cold', 'hot', 'keen', 'soft', 'sour', 'liquid', 'bitter'],
    'phlegm': ['heavy', 'cold', 'mild', 'watery', 'sweet', 'stable', 'slimy'],
}
DISPUTED = {('bile', 'cold')}

OPPOSITE = {
    'dry': 'moist', 'cold': 'hot', 'hot': 'cold', 'light': 'heavy',
    'heavy': 'light', 'subtile': 'gross', 'unstable': 'stable',
    'stable': 'unstable', 'clear': 'slimy', 'slimy': 'clear',
    'keen': 'mild', 'mild': 'keen', 'soft': 'hard', 'sour': 'sweet',
    'sweet': 'sour', 'liquid': 'solid', 'bitter': 'sweet',
    'moist': 'dry', 'watery': 'dry', 'gross': 'subtile',
}


def universe():
    """Every attribute any dosa is given, in first-appearance order."""
    seen = []
    for dosa in ('wind', 'bile', 'phlegm'):
        for a in ATTRIBUTES[dosa]:
            if a not in seen:
                seen.append(a)
    return seen


def vector(dosa, drop_disputed=True):
    """The dosa as a 0/1 vector over the shared attribute space."""
    have = set(ATTRIBUTES[dosa])
    if drop_disputed:
        have -= {a for d, a in DISPUTED if d == dosa}
    return [1 if a in have else 0 for a in universe()]


def discriminating(drop_disputed=True):
    """Attributes that do NOT appear against every dosa.

    An attribute all three share cannot tell them apart, whatever else is true
    of it. This is feature selection done by hand before any entropy is
    computed.
    """
    out = []
    for i, a in enumerate(universe()):
        col = [vector(d, drop_disputed)[i] for d in ('wind', 'bile', 'phlegm')]
        if 0 < sum(col) < 3:
            out.append(a)
    return out


# ----------------------------------------------------------- the rule base
def classify(described):
    """Score a set of described attributes against each dosa.

     A count, not a diagnosis. The explanation is part of the answer,
    because MU's Module II asks for explainable inference and an expert
    system that cannot say why has failed at its job.
    """
    described = set(described)
    scores, why = {}, {}
    for dosa in ('wind', 'bile', 'phlegm'):
        have = set(ATTRIBUTES[dosa]) - {a for d, a in DISPUTED if d == dosa}
        matched = sorted(described & have)
        scores[dosa] = len(matched)
        why[dosa] = matched
    best = max(scores.values())
    winners = sorted(d for d, s in scores.items() if s == best)
    return {
        'scores': scores,
        'matched': why,
        'answer': winners[0] if best and len(winners) == 1 else None,
        'tied': winners if best and len(winners) > 1 else [],
        'explanation': _explain(scores, why, winners, best),
    }


def _explain(scores, why, winners, best):
    if not best:
        return 'No attribute in the description appears in any of the three lists.'
    if len(winners) > 1:
        return ('The description matches %s equally, on %d attribute(s) each, so it '
                'does not decide between them.' % (' and '.join(winners), best))
    d = winners[0]
    return ('%s, because the description gives %s, and Sutrasthana I names those '
            'among the attributes of %s. The counter-measure the text states is an '
            'object of the adverse attribute: %s.'
            % (d.capitalize(), ', '.join(why[d]), d,
               ', '.join(OPPOSITE.get(a, 'the opposite of ' + a) for a in why[d])))


# --------------------------------------------------- the decision tree
def entropy(labels):
    n = len(labels)
    if n == 0:
        return 0.0
    out = 0.0
    for lab in set(labels):
        p = labels.count(lab) / n
        out -= p * math.log2(p)
    return out


def information_gain(rows, attr):
    """rows: [(label, set-of-attributes)]. Split on has/has not."""
    labels = [r[0] for r in rows]
    before = entropy(labels)
    yes = [r[0] for r in rows if attr in r[1]]
    no = [r[0] for r in rows if attr not in r[1]]
    n = len(rows)
    after = (len(yes) / n) * entropy(yes) + (len(no) / n) * entropy(no)
    return before - after


def training_rows(drop_disputed=True):
    rows = []
    for dosa in ('wind', 'bile', 'phlegm'):
        have = set(ATTRIBUTES[dosa])
        if drop_disputed:
            have -= {a for d, a in DISPUTED if d == dosa}
        rows.append((dosa, have))
    return rows


def build_tree(rows, attrs):
    labels = [r[0] for r in rows]
    if len(set(labels)) <= 1:
        return labels[0] if labels else None
    usable = [(information_gain(rows, a), a) for a in attrs]
    usable = [(g, a) for g, a in usable if g > 0]
    if not usable:
        return sorted(set(labels))
    gain, attr = max(usable, key=lambda t: (t[0], -attrs.index(t[1])))
    rest = [a for a in attrs if a != attr]
    return {
        'attribute': attr,
        'gain': round(gain, 4),
        'yes': build_tree([r for r in rows if attr in r[1]], rest),
        'no': build_tree([r for r in rows if attr not in r[1]], rest),
    }


def render_tree(node, indent=0, label=''):
    pad = ' ' * indent
    if not isinstance(node, dict):
        return '%s%s-> %s' % (pad, label, node)
    out = ['%s%sis it %s?  (information gain %.4f)'
           % (pad, label, node['attribute'], node['gain'])]
    out.append(render_tree(node['yes'], indent + 2, 'yes: '))
    out.append(render_tree(node['no'], indent + 2, 'no:  '))
    return '\n'.join(out)


def walk(node, described):
    trail = []
    while isinstance(node, dict):
        a = node['attribute']
        took = a in described
        trail.append('%s %s' % (a, 'yes' if took else 'no'))
        node = node['yes'] if took else node['no']
    return node, trail


TESTS = [
    ('three attributes of wind',        ['dry', 'unstable', 'subtile'],      'wind'),
    ('three attributes of bile',        ['hot', 'sour', 'bitter'],           'bile'),
    ('three attributes of phlegm',      ['heavy', 'sweet', 'slimy'],         'phlegm'),
    ('one attribute only, unique',      ['watery'],                          'phlegm'),
    ('the shared attribute alone',      ['cold'],                            None),
    ('nothing in any list',             ['blue', 'loud'],                    None),
    ('an empty description',            [],                                  None),
    ('keen, which two dosas share',     ['keen'],                            None),
    ('keen with one wind attribute',    ['keen', 'dry'],                     'wind'),
    ('keen with one bile attribute',    ['keen', 'sour'],                    'bile'),
    ('a mixed description, wind leads', ['dry', 'light', 'clear', 'sour'],    'wind'),
    #  Expected None, and the reason is the finding: with the disputed reading
    # dropped, "cold" belongs to wind and phlegm and "hot" to bile, so this
    # description matches all three once and settles nothing. Writing 'bile'
    # here was the first guess and the test caught it.
    ('cold and hot together',           ['cold', 'hot'],                     None),
]


def run_tests(verbose=False):
    passed = 0
    for name, described, expect in TESTS:
        got = classify(described)['answer']
        ok = got == expect
        passed += ok
        if verbose:
            print('%-46s %s  expected %-7s got %s'
                  % (name, 'pass' if ok else 'FAIL', expect, got))
        assert ok, (name, got, expect)
    return passed


def prove():
    u = universe()
    assert len(u) == len(set(u))
    # every dosa gets seven attributes as printed
    for d in ATTRIBUTES:
        assert len(ATTRIBUTES[d]) == 7, d
    # "cold" is printed against all three, so it discriminates nothing
    assert all('cold' in ATTRIBUTES[d] for d in ATTRIBUTES)
    assert 'cold' not in discriminating(drop_disputed=False)
    # dropping the disputed reading makes cold a phlegm-and-wind attribute
    assert 'cold' in discriminating(drop_disputed=True)
    assert abs(information_gain(training_rows(), 'cold')) > 0
    assert abs(information_gain(training_rows(drop_disputed=False), 'cold')) < 1e-12
    # and bile never claims the disputed attribute
    assert classify(['cold'])['matched']['bile'] == []
    # the tree separates all three
    tree = build_tree(training_rows(), discriminating())
    for d in ('wind', 'bile', 'phlegm'):
        leaf, _ = walk(tree, set(ATTRIBUTES[d]) - {a for x, a in DISPUTED if x == d})
        assert leaf == d, (d, leaf)
    run_tests()
    return True


if __name__ == '__main__':
    prove()
    print('### the shared attribute space, %d attributes' % len(universe()))
    print('   ' + ', '.join(universe()))
    print()
    print('### the three vectors')
    print('%-8s %s' % ('', ' '.join('%-9s' % a for a in universe())))
    for d in ('wind', 'bile', 'phlegm'):
        print('%-8s %s' % (d, ' '.join('%-9d' % v for v in vector(d))))
    print()
    print('### information gain of every attribute, disputed reading dropped')
    rows = training_rows()
    for a in universe():
        print('   %-9s %.4f' % (a, information_gain(rows, a)))
    print()
    print('### the tree')
    print(render_tree(build_tree(rows, discriminating())))
    print()
    print('### the ten test cases')
    n = run_tests(verbose=True)
    print('\n%d of %d pass' % (n, len(TESTS)))
    print()
    print('### one answer with its explanation')
    r = classify(['dry', 'unstable', 'subtile'])
    print('   ' + r['explanation'])