Zach Boldyga

I implemented 3D convolutions for TensorFlow.js:
• https://github.com/tensorflow/tfjs

TensorFlow is written in C++ and CUDA and exposes a C API which is then called by other, easier-to-use languages like Python. For nearly all programming languages, using TensorFlow simply means building a client library by writing some wrapper code around the C API.

However, enabling a tool like TensorFlow to run via JavaScript in a web browser is a bit different. With WASM, it's technically possible to run this C++/CUDA code in the browser. But as of 2019, the practical approach to doing inferencing and training of machine learning models inside of a web browser is to use a tool like TensorFlow JS: a from-scratch implementation of TensorFlow's C++ and CUDA code, instead of being written in TypeScript and WebGL.

That said building TensorFlow JS means rebuilding all of the components of a machine learning library from scratch. Aiding in this effort, I built in the ability for this library to handle 3D convolutions that are commonly used in video and time series applications.

This technology currently powers web-based 3D medical image segmentation tools, video effects, and more!

US lab results contain a number of timestamps (always including the original time the test was ordered, and the time the testing was completed and when the result was sent to the patient). Using millions of these examples, a neural-network-based regression model was trained to predict when the ordered test results will be delivered to patients.

If a physician orders a TSH panel from Quest Diagnostics—due to the fact that we've seen over 50,000 of those transactions—our system has quality information to assess when the result will be returned. While relying on deep learning allowed us to avoid complex feature extraction in this implementation, the initial implementation used multivariate linear regression and required feature extraction. Therefore, it's clear that the neural network relies on information like the day of the week and time of day the test was ordered, the type of test, the age of the patient, and the lab and/or region of the US.

This is currently considered proprietary; the code is not included.

Over 1 million patients receive lab results through our system annually, e.g., the results of their blood tests.

In this set of data from laboratories, radiology providers, and hospitals, we experience considerable misinformation. Patient names are misspelled, dates of birth are incorrect or missing, and patient IDs are jumbled or missing.

Generally, a human—your doctor or their staff—will notice and fix this error. But this data corruption prevents the automated matching of patient records into patient charts and can prolong the time it takes for a patient to receive care.

The code seen here is one of the few mechanisms we use to tackle this problem. Machine learning (basic logistic regression), clever string distance metrics, predicate blocking, an inverted index, Chavatal's greedy set cover algorithm, and hierarchical clustering with centroid linkage are all used to create an intuitive patient record correction system that automatically fixes over 90% of corrupted data we receive.

I architected, built, and performed DevOps for over 100 of the microservices that power Scalabull.

Includes:
• An entire, medical-grade data warehouse.
• User-facing platforms built with React, Meteor, chart.js
• REST APIs
• Generation of a variety of clinically-approved PDF formats with conditionally changing layouts and barcodes.
• Integration into SOAP web services provided by Quest Diagnostics and LabCorp.
• Created more than 1,000 HL7 interfaces.Live connections between doctors and clinical laboratories.
• MLLP server and client.
• In-house SFTP server and client.
• Machine learning tools with production-grade deployments.
• ZeroMQ, Redis, and NSQ used for various messaging and key/value store needs.
• Elasticsearch for information discovery.
• Nagios to track system failures and provide real-time alerts to developers.
• A fault-tolerant infrastructure with combined hardware firewalls, dedicated servers, and cloud servers.

My contributions to Apache MXNet have revolved around expanding the maths library capabilities and documentation.

I orchestrated and contributed to the development of multiple open-source extensions to the React JSON-schema Form, a utility for creating user input forms from a JSON schema object on-the-fly. Our plugins allow users to significantly enhance this tool and create enterprise-grade forms from JSON-based configurations.

The projects include:
• Extras: an assortment of fancy widgets (e.g., typehead text fields).
- https://github.com/RxNT/react-jsonschema-form-extras
• Pagination: multipage forms are supported.
- https://github.com/RxNT/react-jsonschema-form-pagination
• Conditionals: a rules engine can be applied to compute values in the form, hide form fields, and manipulate form CSS.
- https://github.com/RxNT/react-jsonschema-form-conditionals
• Form Manager: This makes it simpler to plug all of our utilities together into an enterprise-grade application.
- https://github.com/RxNT/react-jsonschema-form-manager