🖥️🧠💪 Eloquent Attribute Value Prediction
❤️ Machine Learning For Laravel Developers! ❤️
With this package you'll be able to predict attribute values for your Laravel Eloquent models using the power of machine learning! 🌟
With an intuitive syntax you can predict the values of both categorical (string) and continuous (numeric) attributes. Take a look at the examples below.
$animal = new \App\Models\Animal();
$animal->size = 'small';
$animal->has_wings = false;
$animal->domesticated = true;
$animal->name = $animal->predict('name');
// 'cat'
$predictions = $animal->getPredictions('name');
// [
// 'cat' => 0.43,
// 'dog' => 0.40,
// 'bird' => 0.10,
// 'elephant => 0.9,
// ]
$house = new \App\Models\House();
$house->num_bedrooms = 3;
$house->num_bathrooms = 1;
$house->value = $house->predict('value');
// 180000
Installation
To install just run the following Composer command.
composer require divineomega/eloquent-attribute-value-prediction
After installation, you need to set up your model for attribute prediction.
Setup
Let's say you have an IrisFlowers
table that contains data about each of
three species of the Iris flower. In this example, we want to be able to
predict the flower's species given the sepal length and width, and
petal length and width.
First, we need to set up out IrisFlower
model for attribut prediction.
This is done by adding the HasPredictableAttributes
interface and
PredictsAttributes
trait to our model as shown below.
<?php
namespace App\Models;
use DivineOmega\EloquentAttributeValuePrediction\Interfaces\HasPredictableAttributes;
use DivineOmega\EloquentAttributeValuePrediction\Traits\PredictsAttributes;
use Illuminate\Database\Eloquent\Model;
class IrisFlower extends Model implements HasPredictableAttributes
{
use PredictsAttributes;
}
We then need to tell our model which attributes we wish to predict. We do this
by adding the registerPredictableAttributes()
function.
In this example, we want to use predict the species
attribute based on the
sepal_length
, sepal_width
, petal_length
, and petal_width
attributes.
This can be done by returning an array in the following format.
public function registerPredictableAttributes(): array
{
return [
'species' => [
'sepal_length',
'sepal_width',
'petal_length',
'petal_width',
],
];
}
You also need to add the attributes you are using to the $casts
array.
It is important that the machine learning algorithm knows the type of data
stored in each attribute, and that it is consistent.
For our IrisFlower
example, the following format is appropriate.
protected $casts = [
'sepal_length' => 'float',
'sepal_width' => 'float',
'petal_length' => 'float',
'petal_width' => 'float',
'species' => 'string',
];
Training
Before you can make attribute value predictions, you must train a machine learning model on your data. As a general rule, the more data you provide your model, the better it will perform, and the more accurate it will be.
You can train your model(s) using the eavp:train
Artisan command, as shown
in the example below.
php artisan eavp:train \\App\\Models\\IrisFlower
One model will be trained for each of the attributes you wish to predict. When
they are trained, they will be saved into the storage/eavp/model/
directory
for future use.
Be aware that the training process can take some time to complete depending on the amount of data you are using, and the complexity of your machine learning model. Training progress will be output to the console where possible.
You can re-run this command (manually, or on a schedule) to re-train your machine learning model(s). Previously trained models will be replaced automatically.
Prediction
Once you have set up your Eloquent model, and trained your machine learning model(s), you can begin predicting attributes.
For example, to predict the species of an Iris flower, you can create a new
IrisFlower
object and populate a few of its known attributes, then call the
predict
method.
$flower = new \App\Models\IrisFlower();
$flower->sepal_length = 5.1;
$flower->sepal_width = 3.5;
$flower->petal_length = 1.4;
$flower->petal_width = 0.2;
$species = $flower->predict('species');
The predict
method should be passed the attribute name you wish to predict.
It will then returns the prediction as a string or numeric type.
In our example, this should be the 'setosa' species, based on Iris flower data set.
Advanced
Prediction confidence
If you wish, you can also retrieve the machine learning model's
confidence that a prediction is correct. This is done with the getPredictions
method.
$flower = new \App\Models\IrisFlower();
$flower->sepal_length = 4.5;
$flower->sepal_width = 2.3;
$flower->petal_length = 1.3;
$flower->petal_width = 0.3;
$predictions = $flower->getPredictions('species');
/*
array:3 [
"setosa" => 0.69785665879791
"versicolor" => 0.30214334120209
"virginica" => 0.0
]
*/
In this example, you can see that the machine learning model is ~70% confident the flower is a Setosa, ~30 confident the flower is a Versicolor, and 0% confident the flower is a Virginica.
Note that you can only use the getPredictions
method if the attribute you are
attempting to predict the value of is non-numeric.
Changing attribute estimators
By default, attribute values are predicted using K-d Neighbors. This is a more efficient form of a standard K Nearest Neighbors algorithm.
The machine learning algorithm that is used to predict your attribute values is known as an 'estimator'. If you wish, you can modify the estimator which is used for each attribute.
To do this, you need to add a registerEstimators
method to your model.
public function registerEstimators(): array
{
return [
'species' => new MultilayerPerceptron([
new Dense(50),
new Dense(50),
]),
];
}
In the example above, we are changing the estimator for the species
attribute
to a multilayer perceptron classifier (neural network) with two densely connected
hidden layers.
Under the hood, this package uses the Rubix ML library. This means you can use any estimator is supports.
See the Choosing an Estimator page for a list of all available estimators you can use for attribute prediction.