30

I am looking to design a system that will essentially need to make decisions based on input. The input will be a person. 

class Person:
    def __init__(self, name, age, sex, weight, height, nationality):
        self.name = name
        self.age = age
        self.sex = sex
        self.weight = weight
        self.height = height
        self.nationality = nationality

We want to assign each person to a school class based on certain rules.

For example:

Women from the UK between 22-25 should go to class B. Men over 75 should go to class A. Women over 6ft should go to class C.

We will have approximately 400 different rules and the first rule that is met should be applied - we need to maintain the order of the rules.

I am thinking about how to store/represent the rules here. Obviously, you could just have a veeeery long if, elif, elif statement but this isn't efficient. Another option would be storing the rules in a database and maybe having an in memory table.

I would like to be able to edit the rules without doing a release - possibly having a front end to allow non tech people to add, remove and reorder rules.

Everything is on the table here - the only certain requirement is the actually programming language must be Python.

Added for further context

I suppose my question is how to store the rules. At the moment it is one huge long if elif elif statement so anytime there is a change to the business logic the PM does up the new rules and I then convert them to the if statement.

All inputs to the system will be sent through the same list of rules and the first rule that matches will be applied. Multiple rules can apply to each input but it's always the first that is applied.

e.g.

Women over 25 go to Class B
Women go to Class A.

Any women over 25 will be sent to class B even though the second rule also applies.

Input will always contain the same format input - haven't decided where it will be an object or a dict but some of the values may be None. Some Persons may not have a weight associated with them.

noxdafox
  • 14,439
  • 4
  • 33
  • 45
user7692855
  • 1,582
  • 5
  • 19
  • 39
  • 2
    Your question is too broad. Please edit the question to limit it to a specific problem with enough detail to identify an adequate answer. Avoid asking multiple distinct questions at once. See the [How to Ask](https://stackoverflow.com/help/how-to-ask) page for help clarifying this question. – Selcuk Nov 21 '18 at 22:54
  • 3
    Not much more efficient but easier to write could be a file format based on Python expressions. A rule entry could then be `sex == "male" and age > 75 -> A`. The entry can then be split at `->`. The first part goes to Python's `eval()` (with appropriate namespace dictionary) and if it returns `True` the class is taken from the second part. – Michael Butscher Nov 21 '18 at 22:55
  • 5
    It sounds like the most important choice is how to store/represent the rules. Who will be responsible for maintaining the rules -- a programmer, or a business person? How complex can the rules be? Your first example rule is already fairly complex -- `sex == 'f' and age >= 22 and age <= 25`. – John Gordon Nov 21 '18 at 22:56
  • @JohnGordon Yes the question really is how to store/represent the rules. I would like a front end to allow non tech people to add and remove rules. It can be complex as `if x or y, but not z or q, then p` – user7692855 Nov 21 '18 at 23:01
  • It sounds like it may be a Flask or Django app? It's an interesting problem. 400 rules to be edited by a user... would the addition or removal apply to all users or individual users? I think writing an overly long set of if elif could likely be avoided... how many person objects typ? As an aside python classes use Titlecase by convention. – srattigan Nov 22 '18 at 01:19
  • I was thinking Flask for the front end part but still trying to decided (a) how to store the rules (b) how to apply rules to the input. I have updated the question with more details -> The same rule set will be applied to all inputs to the system. – user7692855 Nov 22 '18 at 12:30
  • Maybe you can check https://github.com/tclh123/rule. I also had a similar question before, so I wrote this simple rule engine. You can store your rule in json/yaml strings by using it, and define your context and action in your Django app. – Harry Lee Jun 16 '19 at 05:57

1 Answers1

81

Rather than re-inventing the wheel, I'd suggest you to use some readily available solution. There are several expert systems out there and I'll focus on those which are either in Python or can be used via Python.

CLIPS

CLIPS is an expert system originally developed by NASA. It's considered state of the art and used in university courses when teaching basics of AI. It's a great starting point due to its excellent documentation.

Its syntax is definitely not Python, it rather reminds of Lisp. The advantage of CLIPS is that is a solid C engine which can be fully integrated with any other Python system via its bindings: the older pyclips and the newer clipspy. The bindings allow to embed Python code within the CLIPS language making it very easy to extend.

Rules can be loaded at runtime without the need of restarting the engine which should better suit your need.

PyKE

The Python Knowledge Engine it's a fairly powerful logic programming framework. As for CLIPS, PyKE comes with its own syntax to express rules and relies on Python for implementing the mechanics.

In other words, you write what to do in Python and you express when and how via rules.

Rules can be activated and deactivated on demand. This should allow you to support releaseless updates.

Durable Rules

Durable Rules is a fairly new project with the ambition of supporting multiple programming languages (Python, Node.js and Ruby so far).

Durable Rules allow you to write the whole knowledge base (facts and rules) in Python. The syntax might look a bit weird though, a note in this regards at the end of the post.

I am not sure if you can update the rule-set while the system is online.

Apart from the multiple syntax support, what interest me of this project is the fact the core is a C based implementation of RETE built on top of Redis DB. On a long run, this might lead to some interesting development.

PyKnow, Python Intellect & Business Rules

PyKnow/Experta

Intellect

Business Rules

These projects allow to express knowledge bases mostly in Python. I have never seen them in action and I am not sure about their performance and feature support.

The main reason I recommend against brewing your own rule engine to use in production is that, despite it seems an easy task at first, it quickly becomes evident that the problem domain is way bigger than predicted.

Python OOP nature seems initially a good fit for expressing knowledge as both Rules and Facts could be simple classes. Nevertheless, as soon as the pattern matching becomes a little more complex (Employee must have worked > 3 years in Company which Stock value is < 10$ in the last 3 years) two things become evident.

  1. The limitation of simply using and, or, not, is, ... make things really hard to read
  2. The problem suddenly reveals its exponential nature and performance become a major concern

Moreover, forcing the employees of an organization to use yet-another-in-house-built-language is usually a bad idea. It prevents them from learning something used in broader contexts such as CLIPS or Drools and will get you stuck in a maintenance/documentation loop for a long time.

noxdafox
  • 14,439
  • 4
  • 33
  • 45
  • 5
    `PyKnow` seems to be no longer maintained. There is an active fork [experta](https://github.com/nilp0inter/experta) of the `PyKnow` project. – Jasha Aug 16 '20 at 22:40
  • 1
    Currently, last commit for experta seems to be 1 year ago. It does not seem much more active than the original fork. I will keep an eye on both and update the post if neede. Thanks for highlighting it! – noxdafox Sep 14 '20 at 13:55
  • 2
    It looks like pyke was created in 2010. The download is listed as last being modified in 2010. Is this still relevant? – Evan Gertis Dec 12 '20 at 14:57