Posts in JAVASCRIPT

I had an interesting architectural/process challenge recently. A lot of the projects I've built lately have been for supply chain tools and analytics. I have to collaborate very closely with these supply chain teams around how their data is structured and accessed in order to build these analytics tools to their needs.

The most involved part of that collaboration is with their data analysts. They are excellent with SQL and they know their data structures very well, which is great because I can be more hands-off with business logic in my role. However, they like to frequently iterate on their analytics process, and their data needs to be scrubbed semi-regularly. This results in frequent adjustments to the SQL that hydrates the analytics tools I build. Manually rebuilding, retesting, redploying, and change managing the application on this frequent basis can be time consuming.

We decided to completely separate out the SQL code from the analytics tool code as it's own code repository. I did some quick training with the data analysts to get them set up with a code editor of their choice and an easy Git GUI so they could take charge of all the SQL logic that hydrates the analytics tool. When the analytics tool starts up on the server, it goes to look for those SQL files from the supply chain team's repo. It loads in those files on startup and keeps them available in the application runtime. Anytime the supply chain analysts make an adjustment to an SQL file, the pipeline that deploys the SQL code also triggers a quick restart on the analytics tool. So the tool always has the latest SQL to work with. There's a utility function on startup that validates each SQL file to make sure it's not using certain restricted operations, and fulfills certain minimum data set attributes.

This architecture allows them to make changes and deployments on a much smaller codebase without having to involve development team resources for our change process. They get to iterate on the data as quickly as they like and we get to be hands-off with business logic, so it's a win-win. This process has been working well for us for several months now.

This post continues describing a presentation I gave for my development team on Neural Networks and TensorFlow. Please read Part 1 first.

The second use-case I created was a model for simple plain-language search prediction. The idea I had was that a user could use a search input for the sales allowance reporting tool my team had built. The tool shows users the changes in sales allowances on ad campaigns, and it outputs those reports in a variety of formats depending on what the user needs. A language model might help users find the report type they want.

I had the team send me many different terms and phrases that users might use to find reports in the tool. I compiled all of these into about a hundred different text prompts and assigned each to a corresponding report type as its "intent". This array of prompts and intents became a rudimentary training data set for the model.

For this NN, I set up three nodes in TensorFlow, each with 4 inputs to represent 4 different report types that could be predicted. Once again I used a linear regression loss function and the Adam optimizer to compile the model. The unique part about this model compared to my first example was that I used TensorFlow's Universal Sentence Encoder to create the embeddings for the language model. I was surprised by how easy this was to implement. I just loaded the USE and used the models `embed` method to feed it all of the test prompt data.

With the NN set up and the model trained, I could now feed the endpoint a prompt and TensorFlow would return a set of 4 float values, 0 to 1. Each number corresponded to a report type, and its value was the percent likelihood that the prompt was intended for that report. With some simple TypeScript logic, the endpoint would return a URL for the report type with its value closest to 100%.

My hope was that the team understood how TensorFlow streamlines the setup of a NN and model training for language models, and how we could apply this to real-world use-cases going forward.

To end my presentation, I wanted to help them see visually what TensorFlow was doing, and what some bigger possibilities could be. I found a really cool tool called TensorFlow's Embedding Projector. It uses a 3D visualizer to display data points and correlation in several examples of ML models. A couple examples I used for my presentation were Word2Vec All (showing correlation between words), and Mnist with images (showing how handwritten numbers correlate to actual number values).

I set up a repo for the presentation materials I used here:

https://github.com/jdillman1989/tfjs-express-demo