A Django-powered Akinator-style game driven by a decision tree classifier and a live feedback loop.
PrediNator is a guessing game with a decoupled machine learning core and Django interface. It asks yes, no, and don't know questions, makes interpretable predictions, and learns new characters through user feedback.
PrediNator uses Python to keep the game engine, training loop, and web application straightforward and interpretable, which suits the decision-tree-based design of the product.
PrediNator uses a decoupled architecture between the ML core and the Django web layer.
The prediction engine is built around a decision tree classifier, which keeps the logic fast and interpretable for a question-driven game.
The project also includes data-generation and model-training scripts, not just the runtime interface.
Runs an Akinator-style yes, no, and don't-know flow to narrow down possible characters.
Lets users add new characters when the model fails to guess correctly.
Allows new distinguishing questions to be incorporated so the system improves over time.
Supports production deployment with Gunicorn, PostgreSQL, and WhiteNoise.
Includes CI/CD workflow support for testing and deployment to platforms like Render.
Keeps local development simple with virtualenv, migrations, and data bootstrapping scripts.
Production setup, CI/CD, and future scalability concerns are already part of the way the project is framed.
Separates the ML game logic from the web app so the interface and training flow stay modular.
Lets users teach the game new characters and new distinguishing questions when a guess misses.
Includes a production-oriented deployment setup with Gunicorn, PostgreSQL, WhiteNoise, Render hooks, and GitHub Actions.
Start from a seeded dataset of characters and questions.
Run the decision-tree gameplay loop inside the Django application.
When guesses fail, collect new attributes or questions and retrain the model.
The strongest part of the product is the feedback loop: gameplay and learning are tied together rather than treated as separate concerns.
PrediNator is built around an interpretable game loop where the reasoning path stays visible enough to understand and improve. A decision tree works well for that goal because the product depends on a sequence of narrowing questions rather than opaque pattern matching alone. That keeps the gameplay responsive while making the underlying prediction logic easy to extend.
The learning loop is what gives the project staying power beyond a one-time demo. When the system fails to identify a character, it can capture new information, add differentiating questions, and improve the model over time. That means the web experience and the training process reinforce each other instead of living in separate parts of the product.