500,000 rows left! FGM, or field goals made, is the number of baskets a player made, and PTS, or points, is the number of points they scored.
So let's build our model:
from sklearn.linear_model import LinearRegression
l = LinearRegression()
l.fit(df[["FGM"]].values, df["PTS"])
LinearRegression()
OK, now we've got a trained SciKit-Learn linear regression! Let's graph it to see how we did:
import matplotlib.pyplot as plt
%matplotlib inline
plt.scatter(df["FGM"], df["PTS"])
plt.plot(df["FGM"], l.predict(df[["FGM"]].values), c="g")
[<matplotlib.lines.Line2D at 0x7f99b3b68820>]
The blue dots are our dataset, and the green line is our model. Looking good! This model is ready to deploy.
Every model needs a little input santization, data cleaning, or feature encoding. Ours is no different: We're going to have to handle the null case explicitly, because our linear regression isn't expecting them.
To do that, we'll write a little Python function that checks for nulls and then calls the model. We could also use this function to scale the data, call out to a feature encoder, or any other business logic we might need.
Our little model only expects one input: the number of baskets made. That'll be the argument to our function.
def predictPoints(baskets_made):
# Handle the null case explicitly
if baskets_made == None:
return 0
# Call l, our linear regression
return l.predict([[baskets_made]])[0]
predictPoints(5)
13.285483450179342
Looks like it's working! Let's deploy it. As promised. only one line of code:
mb.deploy(predictPoints)
Deployment "predictPoints" will be ready in a few seconds!
Huzzah! This link takes us to Modelbit, where we can see the code that was deployed, as well as the logs, model version information, and Python environment. (Since we didn’t specify one, we got the default Python 3.9 environment.)
We've also got the URL where the model lives! (Astute readers will note that my co-founder, Tom, named our workspace "Tom's House." 🙄
Anyway let's test the deployed model!
import requests
response = requests.post(
"https://api.modelbit.com/api/d/toms_house/predictPoints/latest",
json = {"data": [[1,5], [2,10], [3, None]]}
)
response.json()
{'data': [[1, 13.285483450179342], [2, 26.069509622647892], [3, 0]]}
Here we called it in batch, asking for 3 predictions. They all worked, including the explicitly-handled null case!
But what if we want to call this from our data warehouse? After all our predictions might be lead scores, or customer health scores. Those are best written back to the database...
If we head back to Modelbit and click the "Snowflake" tab, we get some sample code for Snowflake. You'll see we also support some other warehouse types as well as deploying the code directly into Snowflake itself. For this example though, let's keep it simple.
If we copy that Snowflake sample code into our warehouse and run it, we get a SQL function that can call our model directly from our warehouse!
In fact, we can update the whole table that way! Remember, the column with the number of baskets a player made was called FGM. So let's go ahead and update the table:
That statement called our model 626,111 times, which took a little less than 16 seconds. So we could call out for predictions part of building a dbt model directly in the warehouse, or call it every time a new row is inserted into the table. This way, our table would always have the predictions living alongside the data!
Obviously we're pretty excited about this. We hope you find it useful. If you have questions, or feedback, or just want to chat data science, please don't hesitate to reach out. See you around.
