# Patent

## Title
Feature management platform

## Abstract

Certain aspects of the present disclosure provide techniques for operation of a feature management platform. A feature management platform is an end-to-end platform developed to manage the full lifecycle of data features. For example, to create a feature the feature management platform can receive a processing artifact (e.g., a configuration file and code fragment) from a computing device. The processing artifact defines the feature, including the data source to retrieve event data from, when to retrieve the event data, the type of transform to apply, etc. Based on the processing artifact, the feature management system generates a processing job, which when initiated generates a vector that encapsulates the feature data. The vector is transmitted to the computing device that locally hosts a model, which generates a prediction. The prediction is transmitted to the feature management platform and can be transmitted to other computing devices, upon request.

## Background
INTRODUCTION
Aspects of the present disclosure relate to the operation of a feature management platform configured to manage the full lifecycle of feature data.
BACKGROUND
Within the field of data science and analytics, artificial intelligence and machine learning are rapidly growing. More and more entities and organizations are adopting and implementing such technologies. As the field (and popularity) of artificial intelligence and machine learning grows and further develops, so too does the technology for supporting artificial intelligence and machine learning. One such technology focuses on data processing. Generally, large amounts of feature data are needed to train artificial intelligence and machine learning models. Such data can be used both to train models and to generate predictions for specific use cases based on the trained models.
In order to implement data processing at the scale and level feasible for artificial intelligence and machine learning models, a significant amount of resources is often devoted to the collection, transformation, and storage of data. Not only that, the time and costs associated with developing data processing techniques for artificial intelligence and machine learning models can be high. There is also the risk of generating duplicate feature data, when implementing data processing techniques, resulting in more resources being consumed then necessary. Further, there is also a dependence on data engineers when attempting to manage the full lifecycle of feature data. In such instances, the dependence on data engineers also increases the time with which it takes to provide useful feature data. Additionally, conventional methods of data processing are time-intensive and often lack the latest feature data, preventing timely generation of predictions by artificial intelligence and machine learning models, such as for fraud detection, user support, and so forth. As a result, organizations and entities implementing artificial intelligence and machine learning models may base decisions on low quality predictions (e.g., predictions based on old feature data).
Conventional methods attempt to address the shortcomings (as described above) of data processing of feature data. However, conventional methods are often standalone ad hoc solutions that lack governance, model integration, and flexibility to create feature data for real-time and batch aggregations. Additional limitations of conventional methods include a lack of reusability and shareability of the feature data as well as the failure of the conventional methods to manage the entire lifecycle of feature data in a reliable, scalable, resilient, and easily useable manner.
As such, a solution is needed that can overcome the shortcomings of the conventional methods to manage the complete lifecycle of feature data in a scalable and reusable manner.
BRIEF SUMMARY
Certain embodiments provide a method for a feature management platform that operates to manage feature data. The method generally includes receiving, at a feature management platform from a first computing device, a processing artifact that defines a feature associated with a corresponding data source and a transform. The method further includes generating, based on the processing artifact, a processing job configured to retrieve event data from the data source. The method further includes initiating the processing job that includes retrieving the event data from the corresponding data source, applying the transform to the event data to generate a set of feature values, and encapsulating the set of feature values within a feature vector to store in a feature store of the feature management platform. The method further includes transmitting the feature vector representing the set of feature values to a model hosted on the first computing device. The method further includes receiving, from the first computing device, a prediction generated by the model. The method further includes transmitting the prediction to the feature store of the feature management platform. The method further includes upon receiving a request from a second computing device for the feature, transmitting the feature to the second computing device from the feature store.
Other embodiments provide systems for a feature management platform that operate to receive and provide feature data and/or predictions. Additionally, other embodiments provide non-transitory computer-readable storage mediums comprising instructions for a feature management platform that operates to receive and provide feature data and/or predictions.
The following description and the related drawings set forth in detail certain illustrative features of one or more embodiments.



BRIEF DESCRIPTION OF THE DRAWINGS
The appended figures depict certain aspects of the one or more embodiments and are therefore not to be considered limiting of the scope of this disclosure.
FIG. 1 depicts an example feature management platform, according to an embodiment.
FIG. 2 depicts an example environment of the feature management platform interacting with a computing device, according to an embodiment.
FIG. 3 depicts an example pipeline of the feature management platform, according to an embodiment.
FIG. 4 depicts an example configuration file of the feature management platform, according to an embodiment.
FIG. 5 depicts an example flow diagram of the feature management platform interacting with one or more computing devices, according to an embodiment.
FIG. 6 depicts an example flow diagram of the feature management platform interactions, according to an embodiment.
FIG. 7 depicts an example server for the feature management platform, according to an embodiment.
FIG. 8 depicts an example flow diagram of a computing device interacting with a feature management platform, according to an embodiment.
FIG. 9 depicts an example computing device, according to an embodiment.



To facilitate understanding, identical reference numerals have been used, where possible, to designate identical elements that are common to the drawings. It is contemplated that elements and features of one embodiment may be beneficially incorporated in other embodiments without further recitation.
DETAILED DESCRIPTION
Aspects of the present disclosure provide apparatuses, methods, processing systems, and non-transitory computer readable mediums for the operation of a feature management platform, which is an end-to-end platform for managing the full lifecycle of feature data (e.g., discovery, creation, use, governing, and deployment of feature data).
Organizations and entities that depend on feature data processing for artificial intelligence and/or machine learning (AI/ML) models can implement a feature management platform. Due to the pluggability and multi-tenancy nature of the feature management platform, multiple types of computing devices (or client devices) can connect to (or “plug” into) the feature management platform for discovering, creating, sharing, re-using, etc., feature data, including stateful and stateless features. Such data is used for training and implementing use cases of models on computing devices. Further, the feature management platform can interact with computing devices and/or models to receive and distribute generated predictions.
Generally, feature data can include event data that is featurized, such as geographic lookups (e.g., based on IP addresses, zip codes, and other types of geographic identifying data), counts of user activity (e.g., clicks on a link, visits to a web site, and other types of countable user activity), and other types of featurized data based on event data collected by an organization. The event data can include raw data gathered through interactions and operations of the organization. For example, an organization that provides user support of products and/or services offered by that organization can collect information (e.g., event data) such as IP addresses of users accessing online user support, number of times a user contacts user support (e.g., via phone, email, etc.), and so forth. Such event data can be featurized to generate feature data, which can include stateful features and stateless features, by the feature management platform. For example, stateful features can be calculated using aggregation operations over a period of time (e.g., count, count distinct, sum, min, max, etc.). Stateless features can be the last value (or latest in time value) of a feature (e.g., a last IP address of a user).
The feature data can be retrieved (e.g., via computing devices) from the feature management platform to train and implement models to generate predictions that can assist the organization in making operational decisions. Further, the feature management platform can interact with computing devices to receive and distribute predictions generated to other models and/or computing devices, which in turn can reduce the consumption of resources by an organization including computing resources, time, money, etc.
The feature management platform provides the tooling and framework for managing data transformations, which in turn allow for creation of feature data for AL/ML models. The feature management platform includes components that enable the sharing and reusability of feature data (e.g., stateful and stateless features) to other models as well as reducing data corruption and data duplication. Further, the feature management platform can automate aspects of data processing such that dependence on data engineers is reduced.
As part of managing the full lifecycle of feature data, the feature management platform can create the feature data. In some embodiments, the feature management platform includes an API that allows a computing device to search and discover (e.g., by providing the interface to the computing device) whether a certain feature and/or prediction exists within the feature management platform. For example, the computing device can search via a user interface the feature metadata of a feature registry in the feature management platform to determine whether a feature is stored on a data store of the feature management platform (e.g., a fast retrieval database or a training data database). In cases where the feature management platform does not already include the feature and/or prediction, the feature management platform is capable of creating the feature for and/or providing prediction to the computing device.
In some cases, a feature can already be present in the feature management platform (e.g., the feature can be previously generated). In such instances, a computing device can search the feature registry via a user interface and retrieve the feature (e.g., as one or more feature vectors, tensors, etc.) from a data store of the feature management platform. In other cases, the feature may not exist in the feature management platform. In such instances, the feature management platform can generate the feature to provide to a computing device.
To generate and manage the full lifecycle of a feature, the feature management platform may include an API that defines a pipeline for generating the feature (e.g., generating a processing job) based on a processing artifact received from a computing device that can include a configuration file and/or code fragments to define the feature. The definition of the feature includes, at least, a corresponding data source and transform. For example, the transform can refer to the type of feature calculation for the feature management platform to perform on data from the data source. The feature management platform generates, based on the processing artifact, a processing job for the feature management platform to perform. For example, the processing job is configured to retrieve event data from a data source. In some cases, the event data can be retrieved from a data source at a scheduled time. In other cases, the event data can be retrieved as a continuous data flow.
In some cases, the configuration file can include which data source(s) to retrieve event data from, what type of transforms (or calculations) to perform on the event data, how far back and/or how long to retrieve event data, where to provide the feature vectors, etc. In such cases, the API of the feature management platform can retrieve such information from the configuration file to define the pipeline for generating the feature.
In some cases, code fragments received by the feature management platform can include functional data that can include data operations for generating feature data (e.g., aggregations, joins, and other types of data operations). For example, a computing device can provide (or transmit) the code fragment(s) along with the configuration file. In another example, the code fragment may have been provided to the feature management platform prior to the configuration file and can be re-used. In such cases, the processing artifact received from a computing device can include just the configuration file, and the feature management platform can use code fragments previously provided (e.g., as directed by the configuration file). The configuration file can be an object notation or data serialization configuration file format, such as a JSON file, a HOCON file, an XML, file, a YAML file, a ZIP file, a JAR file, and so forth.
Subsequent to generating the processing job, the processing job is initiated in order to retrieve event data from the data source (e.g., as defined in the processing artifact) and generate a feature that can be encapsulated in a vector (or tensor) that represents the feature data based on the transformation(s) applied to the event data. The feature management platform can then transmit the vector. In some cases, the feature management platform can transmit the vector back to the same computing device that provided the processing artifact. In other cases, the feature management platform can transmit the vector to a second computing device (e.g., as directed by the computing device that provided the processing artifact).
Further, the vector can be stored in the feature management platform and be made available to other computing devices connected to the feature management platform for the purpose of allowing those computing devices to access and use the vector without having to duplicate the work or waste resources. For example, the vector can be stored in a feature store such as a fast retrieval database or a training data database, and the corresponding metadata can be stored in a feature registry.
In some cases, a computing device can use the vector for training and creating a model on the computing device. In other cases, the vector is used by a model stored locally on the computing device as part of a use case to generate a prediction. In such cases, the feature management platform can receive a transmission from the computing device of the prediction generated by the model. The prediction can be stored in the feature management platform and can be transmitted to other computing devices, including downstream clients. Further, the prediction(s) can be input to other models hosted local on other computing devices connected to the feature management platform.
Such a feature management platform capable of managing the full life cycle of feature data minimizes dependency on data engineering (which can be resource intensive and costly). Additionally, the feature management platform reduces the time for creation, modification, deployment, and use of features because the feature management platform is a consolidated platform of components that can manage the entire lifecycle of feature data. Through automation of data processing as well as components of the feature management platform (e.g., feature registry, feature queue, etc.), the feature management platform can allow a plurality of different types of computing devices to connect to, access, and interact with the feature management platform. Further, with the connection to the feature management platform, the computing devices can discover, create, implement, share, re-use, etc., feature data without the risk of feature data duplication and expending unnecessary resources. For example, without the feature management platform, data engineers may generate non-real time feature data, including duplicate instances of feature data, that would not be reusable.
Example Feature Management Platform
FIG. 1 depicts an example framework 100 of a feature management platform 102. The feature management platform 102 is a processing framework that supports the complete lifecycle management of feature data, including stateful and stateless features. For example, the feature management platform 102 supports the creation, discovery, shareability, re-usability, etc. of feature data among a plurality of computing devices that connect to the feature management platform 102.
In one embodiment, the processing framework of the feature management platform 102 supports feature calculations (including stateful feature calculations), a feature queue, and various attached storages. For stateful feature calculation, the feature management platform 102 is able to keep track of a feature data, so that the feature management platform 102 can provide stateful feature data generated based on a stateful feature calculation to one or more computing devices. In some cases, the feature management platform 102 can also support a stateless feature (e.g., by determining the last value of a feature).
The feature management platform 102 includes (or is associated with) a set of components. For example, one or more components of the feature management platform 102 can be components that democratize (or e.g., make accessible) the feature management platform 102 infrastructure. Other components of the set of components of the feature management platform 102 “face” or interact directly with computing devices. Some components of the feature management platform 102 can be shared components, external services, data sources, or integration points. Due to the integration of all of the components, the feature management platform 102 is able to provide feature data (e.g., stateful or stateless features) to computing devices for AI/ML models hosted thereon and manage the full lifecycle of feature data (e.g., discovery, creation, use, deployment, etc.).
In some cases, a distributed system can implement the feature management platform 102, such that the components of the feature management platform 102 can be located at different network computing devices (e.g., servers).
In one embodiment, the feature management platform 102 can include feature processing component 104, a feature queue 106, an internal state 108, a workflow scheduler 110, a feature registry 112, a compliance service 114, an aggregated state 116, a fast retrieval database 118, a training data database 120, metric data 122, data sources 124, and persistent data 126. The feature management platform 102 can interact with a plurality of computing devices 128. Due to the multi-tenancy of the feature management platform 102, multiple computing devices 128 can connect to, access, and use the feature management platform 102. In some cases, a computing device 128 can submit requests for feature data and/or prediction(s). In other cases, a computing device 128 can provide processing artifacts (e.g., a configuration file and/or code fragments). In other cases, the computing device 128 can retrieve feature data and/or predictions from feature management platform 102. For example, the computing device 128 can retrieve a prediction stored by the feature management platform 102 that was generated by another computing device that locally hosts a trained model. In another example, the computing device 128 can retrieve feature data from the feature management platform 102 as a feature vector message. Computing devices 128 can include a computer, laptop, tablet, smartphone, a virtual machine, container, or other computing device with the same or similar capabilities (e.g., that includes training and implementing models, serving predictions to applications running on such computing device, and interacting with the feature management platform).
The feature processing component 104 of the feature management platform 102 can include an API for implementing transforms on event data (e.g., streaming or batch data) in order to generate feature data (or feature values) including stateful features and stateless features. Event data can include raw data from data sources associated with the feature management platform 102. For example, in the context of an organization that provides service(s) and/or product(s), the raw data can include user information (e.g., identifiers), IP addresses, counts of user action (e.g., clicks, log in attempts, etc.), timestamps, geolocation, transaction amounts, and other types of data collected by the organization.
In some cases, the feature management platform 102 can receive a processing artifact from a computing device 128. For example, the computing device 128 can be associated with an organization that is associated with (and can connect to) the feature management platform 102. Based on the processing artifact, the feature processing component 104 can generate and initiate a processing job that generates feature data.
The processing artifact can include a definition of the feature, including what data sources 124 to retrieve event data from, what transform(s) to apply to the event data, how far back and/or how long to retrieve event data, where to provide the feature vectors, etc. In such cases, the feature processing component 104 can retrieve event data from a data source 124 and apply one or more transformations to the event data to generate feature data, based on the feature defined in the processing artifact.
The data sources 124 can include sources of batch and streaming data that connect to the feature management platform 102. In some cases, the event data from data sources 124 can be either streaming data or batch data collected by the organization(s) associated with the feature management platform 102. In order for the feature processing component 104 of the feature management platform 102 to transform event data into feature data or values (e.g., in a feature vector), event data can be retrieved from data sources 124 that are exposed (or connected via, e.g., APACHE SPARKTM) to the feature management platform 102. For example, the event data can be retrieved via the API of the feature processing component 104. In some cases, the data sources 124 can include KAFKA® topics (e.g., for streaming data). In other cases, the data sources 124 can include Hive tables or S3 buckets (e.g., for batch data by the feature management platform 102).
The feature processing component 104 of the feature management platform 102 can be supported by analytics engines (e.g., APACHE SPARKTM) capable of data transformation of both streaming and batch data (e.g., APACHE KAFKA® topic(s)), APACHE HIVETM tables, AMAZON® S3 buckets). The feature processing component 104 can implement transforms by leveraging the API. In some cases, the API can be built on top of APACHE SPARKTM. The API of the feature processing component 104 can support, for example, Scala, SQL, and Python as interface languages as well as other types of interface languages compatible with the API.
One aspect of the feature processing component 104 includes a pipeline (as described in FIG. 3) that provides the feature processing component 104 of the feature management platform 102 the ability to process event data in either streaming or batch mode to generate feature data. Further, based on the pipeline, the feature processing component 104 component can backfill feature values and allow users of the feature management platform 102 to control the featurization logic and aggregation logic (e.g., by accepting processing artifacts from computing devices). In some cases, the feature processing component 104 can include a pipeline for each computing device 128 connected to the feature management platform 102 as part of multi-tenancy support of the feature management platform 102, providing access and service to more than one computing device 128.
Upon the feature processing component 104 generating and initiating a processing job, the resulting output of the feature processing component 104 is a set of feature values (e.g., feature data). In some cases, the feature data may be encapsulated as a vector (or a set of feature vectors or tensors) and published on a feature queue 106. For example, upon determining the latest in time value of a feature (e.g., the stateless feature), the feature value can be encapsulated as a vector. In other cases, the feature data (e.g., a stateful feature) can be generated based on the feature values. For example, the feature values can be stored in an aggregated state 116 (e.g., a cache external to the feature processing component 104) and retrieved by the feature processing component 104 when an aggregation time window is complete. Upon retrieving the feature values, the feature processing component 104 can implement aggregation logic to generate the stateful feature based on the aggregated feature data (or values). Once generated, the stateful feature can be encapsulated within a vector, tensor, or the like.
The feature queue 106 of the feature management platform 102 may comprise a write path to a multi-storage persistent layer of the feature management platform 102 (e.g., a fast retrieval database 118, a training data database 120, or other type of database). Once feature vectors are generated by the feature processing component 104, the feature vectors can be published on the feature queue 106 to provide to computing device(s).
Additionally, the feature queue 106 is a queue that can protect the multi-storage persistent layer of the feature management platform 102 from “bad” code as a security measure to prevent data corruption. The feature queue 106 can act as an intermediary that can provide isolation of components in the feature management platform 102 that face the computing device by decoupling and abstracting featurization code (e.g., code fragment in the processing artifact) from storage. Further, the abstraction of the feature queue 106 is for both streaming and batch mode operations of the feature management platform 102.
Additionally, the feature queue 106 can include feature spaces, which can be “spaces” between published vector data. For example, the feature queue 106 can separate feature messages (e.g., vector messages) into groups or subsets prior to publishing. The feature queue 106 can separate each pipeline of feature processing from a computing device (e.g., to monitor and create alerts for feature(s)). In doing so, the feature queue 106 can allow for use case isolation and multi-tenancy support on the feature management platform 102.
For example, as more than one computing device 128 can connect to the feature management platform 102, the feature queue 106 can provide separation for the result of each processing job for each computing device. The feature queue 106 can provide feature parity for all data points across all storage options and a single monitoring point for data quality, drift, and anomalies as well as pipeline integrity.
The internal state 108 is a shared component of the feature management platform 102. In some cases, the internal state 108 is a service and/or database that stores information regarding the state of all applications and/or components running on the feature management platform 102. For example, data stored in the internal state can include offsets, data markers, data processing and/or privacy regulations (e.g., California Consumer Privacy Act (CCPA)). The internal state 108 also includes a copy of feature metadata (or meta information) from the feature registry 112 and specific configuration items that assist in the operation of the feature management platform 102. Such storage of feature metadata and specific configuration items within the internal state 108 can be retrieved from and pushed to by the feature processing component 104 of the feature management platform 102 without any user intervention. For example, a copy of configuration information can be retrieved from the configuration file and synced to the feature registry, which can provide a user interface (e.g., via the API) to a computing device for querying information regarding features.
The workflow scheduler 110 can schedule when feature processing jobs (e.g., a processing job, a feature logic calculation, an aggregation operation, etc.) can run in the feature management platform 102. In some cases, the workflow scheduler 110 can be a tool, data manager, or service capable of executing processing jobs. For example, a workflow scheduler 110 can be based on Jenkins, APACHE AIRFLOWTM, ARGO EVENTSTM, or other similar tool, manager, or service capable of scheduling the workflow of processing jobs.
The feature registry 112 component is a central registry of the feature management platform 102. The feature processing component 104 of the feature management platform 102 can parse configuration files received from computing devices 128 and register in the feature registry 112 the features generated (as described in the configuration file) by the feature processing component 104, including stateful features and stateless features. The features registered in the feature registry 112 are discoverable (e.g., based on metadata) and can be consumed by other use cases (e.g., by other computing devices requesting the feature for locally hosted models). For example, to discover a feature, the feature registry 112 can provide a user interface via the API of the feature management platform.
In some embodiments, the feature registry 112 is a feature metastore that can leverage a metadata framework for storing and managing feature data. For example, the feature registry 112 can leverage APACHE ATLASTM for feature data storage and management. The feature registry 112 can be queried to discover feature computations for reuse that have been previously implemented and registered to the feature metastore.
Further, the feature management platform 102 may be configured to comply with self-service data governance and compliance regulations (e.g., privacy laws) by registering feature data in the feature registry 112 and requiring specific key columns in feature datasets that contain user identifiable data. In some cases, a connected cascade of indexing and delete jobs in compliance with governance and compliance regulations can be triggered automatically (e.g., without user involvement) by the feature management platform 102 to manage the feature data in the feature registry 112 and attached storage layers (e.g., delete data from the fast retrieval database 118, training data database 120, and aggregated state 116).
The compliance service 114 is a component of the feature management platform 102 that is an automated workflow that ensures data is processed according to compliance regulations. For example, the compliance service 114 can monitor and ensure that data is deleted in accordance with privacy laws (e.g., CCPA). The compliance service 114 can generate an audit of data processing for the feature management platform 102. For example, the compliance service 114 can create reverse indices on a given schedule and leverage the reverse index when performing delete requests and confirming deletion of data. In some cases, the feature management platform 102 can generate a status report of the deleted jobs.
In the instance of deleting data from a feature management platform 102, the delete job can be defined in a workflow and orchestrated by a data manager of the compliance service 114. For example, a computing device can provide a request (e.g., on behalf of a user, entity, organization, etc.) to delete data in accordance with a law or regulation, such as the CCPA. Such request can be received via an API and stored in the internal state 108. Upon reaching the scheduled time for deleting data according to the request, the compliance service 114 can determine all identifiable data per the request and delete the data from data store(s). In some cases, the workflow of the delete job can be defined by services capable of organizing and cleaning data (e.g., AWS GLUETM, KUBERNETESTM, etc.).
An aggregated state 116 of the feature management platform 102 includes a collection of feature data based on user-defined functions (e.g., feature calculation logic, aggregation logic, etc.). In this example, the aggregated state 116 is a distributed cache, external to feature processing component 104, which allows the feature management platform 102 to retain data state as aggregated feature data over a period of time (e.g., a number of distinct users per historic IP, a number of logins in a certain time period, etc.). In some cases, the data state can include all interim feature values that support a calculation of an aggregate function. In other cases, the aggregated state 116 can create and hold aggregated values over time per user per feature in order to provide model scorings (e.g., model scorings from AI/ML models).
In some cases, the aggregated state 116 can be reused for multiple features, which adds to the reusable capability of the feature management platform 102. For example, the stateful feature generated based on data from the aggregated state 116, as well as the data in the aggregated state 116, can be requested by and provided to other computing devices without having to expend additional resources. The stateful feature can be stored in the fast retrieval database 118 and/or the training data database 120, and upon receiving a request for the stateful feature, the feature management platform 102 can provide the requested stateful feature without having to re-generate the feature.
Further, the aggregated state 116 is isolated, which makes such cache independent of application errors and failures as well as infrastructure changes to the feature management platform 102. Also, the implementation of the aggregated state 116 by the feature management platform 102 can result in sub millisecond latency of featurization transaction, which can enable close to real time prediction for AI/ML, models that receive the stateful feature (as well as other feature data stateless feature(s)). In some cases, the aggregated state 116 can endure a throughput of 200% more (e.g., 650,000 TPS or more) for a single use case.
The fast retrieval database 118 (e.g., an online data store) and the training data database 120 (e.g., an offline data store) are each a type of feature store and represents a dual storage system for the feature management platform 102. As part of the dual storage system, persistent data 126 is stored within the fast retrieval database 118 and training data database 120. The persistent data 126 may comprise feature values that are stored for model use cases or training.
For example, the fast retrieval database 118 can include recently generated feature data that can be provided to a model hosted locally on a computing device to generate real-time predictions (e.g., for model use cases and/or inferences). The fast retrieval database 118 can store the most recent (or latest) feature data at a low latency. The training data database 120 can include feature data that can be provided to train a model hosted locally on a computing device (e.g., for model training). The training data database 120 can include all of the generated feature data, including previously generated feature data.
In one example, the feature management platform 102 can generate a stateful feature regarding the number of distinct IP addresses up to a given point in time for each user name. To train a supervised machine learning model on a computing device that can generate a label for user name n at some point in time t in the past, the value of the count distinct feature for the user name n at time t can be retrieved from the feature management platform 102. In particular, the training data database 120 can include for each feature and entity, an ordered set of timestamped feature values. Such data is transmitted to the computing device 128 to train the supervised machine learning model. For a prediction or real-time inference, regarding the most recent (or up-to-date) feature value of the IP address for a user name, then such data can be retrieved from the fast retrieval database 118, which includes the latest feature values.
In some cases, the dual storage system can include a scalable database, such as a DYNAMODBTM. The persistence layer of the dual storage system can serve recent feature values at low latency. In some cases, the feature values are grouped and/or compressed (e.g., by using Protobuf). Additionally, the dual storage system of the fast retrieval database 118 and the training data database 120 includes “smart updates” that prevent older feature values from being overwritten by new feature values during feature revisions (e.g., that are generated by the feature processing component 104). In some cases, the feature management platform 102 can include other types of data storage, such as a persistent database, for storing persistent data such as timestamp data.
The metric data 122 is generated by transformation of the event data that is related to the pipeline or processing job execution. The metric data 122 can be used to monitor the performance of processing jobs and to understand operation metrics. In some cases, the metric data 122 can be monitored via a monitoring platform (e.g., WAVEFRONTTM by VMWare). In other cases, the metric data 122 can be used to create alerts for the feature management platform.
Example Environment of the Feature Management Platform
FIG. 2 depicts an example environment 200 of the feature management platform 202. The example environment 200 includes a feature management platform 202, a computing device 204, and a data source 206.
The feature management platform 202 generally is an end-to-end platform capable of managing the complete lifecycle of feature data. The feature management platform 202 includes a set of components (as further described in FIG. 1) that enables such management of feature data including a feature registry and a feature queue.
In one embodiment, the feature management platform 202 can interact with one or more computing devices 204. The computing device 204 (or client device) can include, for example, a smartphone, a tablet, a desktop computer, a laptop computer, a virtual machine, container, or other computing device with the same or similar capabilities (e.g., that includes training and implementing models as well as serving predictions to applications running on such computing device).
The computing device 204 can request a prediction and/or feature data from the feature management platform 202. The feature management platform 202 can provide the computing device 204 a user interface to interact and search the feature management platform 202 (e.g., the feature registry for feature data and the feature stores for prediction). In some cases, the prediction and/or feature data may be stored at the feature management platform 202. In such cases, the feature management platform 202 can provide the prediction and/or feature data to the computing device 204.
In other cases, the prediction and/or feature data may not be present within the feature management platform 202. In such cases, the feature management platform 202 can generate the feature data based on a processing artifact received from the computing device 204. Further, the feature management platform 202 can provide the prediction to the computing device after receiving the prediction generated by another computing device.
In some cases, the computing device 204 providing the processing artifact and the computing device 204 receiving the feature data from the feature management platform 202 for a locally hosted AWL model 208 are different computing devices 204. For example, a first computing device 204 can provide a processing artifact regarding a feature and direct the feature management platform 202 to provide the feature data to another computing device 204 with a locally hosted AI/ML model 208.
In other cases, the computing device 204 requesting feature data (e.g., by providing the processing artifact or searching the feature registry) also includes a locally hosted AI/ML model 208. For example, the computing device 204 can provide a processing artifact to the feature management platform 202 and direct the feature data be sent to the same computing device 204 that also includes a locally hosted AWL model 208.
The computing device 204 interacts with the feature management platform 202. In some cases, the feature management platform 202 provides (or transmits) feature data to the computing device 204 to train the AI/ML model 208. In other cases, the feature management platform 202 can provide feature data to the AI/ML model 208 on the computing device 204 for an AI/ML model 208 use case to generate a prediction. In instances when the feature management platform 202 provide feature data to the computing device 204, such data may previously exist at or is created by the feature management platform 202.
In one embodiment, the feature management platform 202 can create feature data for a computing device 204. The computing device 204 can interact with the feature management platform 202 by searching the feature management platform 202 for a feature. For example, the computing device 204 can provide a request to the feature management platform 202 for a feature and/or prediction. In such an example, the feature management platform 202 can provide an interface via the feature management platform API to the computing device 204. Upon receiving the user interface, the computing device 204 can input data defining the requested feature. Based on the input from the computing device 204, the feature management platform 202 can make a determination whether a feature is registered in the feature management platform 202 (e.g., based on the metadata of a feature stored in the feature registry).
If the feature already exists at the feature management platform 202 (e.g., such that the feature management platform 202 is currently calculating the feature), then the feature management platform 202 can transmit a vector (representing the feature data) as a message (e.g., a single vector message) to the computing device 204. By providing the vector, the feature management platform 202 can share and reuse feature data without unnecessary duplication and wasting resources (e.g., processing time, money, etc.). For example, when a feature calculation (e.g., pipeline) is on boarded to the feature management platform 202, the feature calculation can be used by a model on a computing device 204 as the values associated with the feature calculation is available in the feature management platform 202 and queries can be made via a software development kit (SDK) and/or API.
In the instance that the requested feature is not found in the feature registry of the feature management platform 202, then the computing device 204 requesting the feature can transmit a processing artifact to the feature management platform 202. The processing artifact that is received by the feature management platform 202 can include a configuration file and/or a code fragment. The processing artifact defines the feature requested, include which data source 206 to retrieve event data from and the transform to implement (or apply) to the event data. The feature management platform 202 can retrieve event data from streaming data and/or data stored in batch mode.
The ability to search (or discover) a feature on the feature management platform 202 as well as create features via the feature management platform 202 increases the reusability of the feature as well as reduces the amount of resources expended in training and/or implementing a model with the feature data.
Once the feature management platform 202 receives the processing artifact, the feature management platform 202 generates a processing job that is initiated in order to generate the vector that is then later transmitted back to the computing device 204. As part of initiating the processing job, the feature management platform 202 retrieves events from a data source 206, as defined per the processing artifact. The events are retrieved as event data, according to the processing job. In some cases, the event data is streaming data or batch data of events previously collected and stored by the data source 206.
After the feature management platform 202 retrieves the event data from the data source 206, the feature management platform 202 generates feature data by applying data transforms (or feature calculations) to the event data as per the processing artifact. In doing so, the feature management platform 202 can create feature data, which can be transmitted to the computing device 204 for use by the AI/ML model 208. In some cases, the feature management platform 202 transmits the features as single message including the vector, tensor, and the like that represents the feature data.
Further, the feature management platform 202 can store the feature data generated in the feature registry (e.g., as metadata) so that when other computing devices seek the same feature data, the feature management platform 202 can transmit such data without having to expend unnecessary resources. This also promotes sharing and re-usability by the computing devices associated with the feature management platform 202.
Example Pipeline of the Feature Management Platform
FIG. 3 depicts an example pipeline 302 of the feature management platform. In some embodiments, the example pipeline 302 is part of the feature processing component of the feature management platform. The feature management platform includes a platform API for users to interact with the feature management platform. In some cases, the API is built on top of APACHE SPARKTM and can support Scala, SQL, and Python as interface languages.
The API of the feature management platform is an entry point for a computing device (e.g., via user interface(s)) and is responsible for the generation and execution of processing jobs via a pipeline 302. In some cases, the API defining the pipeline 302 can operate in either structured streaming or in batch mode. For example, the pipeline 302 can process event data from a streaming data source or a batch data source. The same API is offered to each computing device (e.g., via user interface(s)) and can backfill features. The API defines the pipeline 302 and includes a data source 304, preprocessor(s) 306, a feature calculation module 308, a featurizer 310, and a feature sink 312. In some cases, a user interface is provided by the API for each aspect of the pipeline 302 to define the feature (e.g., data source 304, preprocessor(s) 306, a feature calculation module 308, a featurizer 310, and a feature sink 312). The API can be agnostic and implemented on different types of databases.
For example, the feature management platform can receive a processing artifact (e.g., a configuration file and/or code fragment). Based on the processing artifact received, the API of the feature management platform can define the pipeline 302 along with input received via the user interface(s) provided by the API to the computing device(s) for generating a feature from event data. In some cases, the data source 304 (e.g., defined in the configuration file) retrieves event data for feature processing by the pipeline 302.
In some cases, the data source 304 as defined (e.g., in the configuration file) for the feature can include a batch data source and/or a streaming data source from which to retrieve data from to generate feature data. In such cases, the API of the feature management platform can generate a batch processing job and/or a real-time processing job. The batch processing job can be initiated by the pipeline 302 to generate feature data for a defined period of time, up to the present time. Upon reaching the present time, the batch processing job can be completed. In some cases, where the data source defined includes both a batch and streaming data source, once the batch processing job is completed, then the real-time processing job can be initiated. For example, the pipeline 302 can retrieve event data from a batch data source for the batch processing job and can retrieve event data from the streaming data source for the real-time processing job once the batch processing job is completed.
The data source 304 can include HIVETM, EBUSTM, S3TM, or other data sources capable of storing data. The preprocessor(s) 306 can be chained together or sequentially executed to filter out event data. For example, if click stream data regarding the “clicks” on a web page, link, etc., was retrieved from the data source 304, then the preprocessor(s) 306 can filter out (or remove) test data from the click stream data prior to calculation by the feature calculation module 308.
The feature calculation module 308 can perform operations (e.g., as defined by a user interface and/or configuration file). For example, the feature calculation module 308 can perform feature logic calculations and aggregation operations (e.g., a count, average, and other types of operation on event data and/or feature data). The feature calculation module 308 can implement the aggregation operation(s) as defined by the processing artifact to generate a stateful feature.
In some cases, the feature calculation module 308 can perform the calculation of event data in parallel in the pipeline 302. The feature calculation module 308 can generate a table of results, and the featurizer 310 can transform the table into a feature vector format. The featurizer 310, upon generating the feature vector by transforming the table results of the feature calculation module 308, can then push the feature vector to the feature sink 312. In some cases, the feature sink 312 can be a feature queue of the feature management platform (e.g., a feature queue 106 as described in FIG. 1) that publishes the feature vector for a computing device.
Example Configuration File
FIG. 4 depicts an example configuration file 400. In one example, the feature management platform can receive the configuration file 400 from a computing device. In such cases, the computing device provides the configuration file as part of a processing artifact (with a code fragment) when requesting a feature in cases where the feature management platform does not include the feature in the feature registry. For example, the computing device can generate the configuration file and transmit the configuration file 400 as part of the processing artifact to the feature management platform.
The configuration file 400, along with code fragments, defines the feature requested as well as identifies the data source to retrieve event data and the type of transform to be applied to the event data. In some cases, the configuration file 400 received from a computing device can be an object notation or data serialization configuration file format, such as a JSON file, a HOCON file, an XML, file, a YAML, file, a ZIP file, a JAR file, and so forth.
In the depicted embodiment, the following data types are defined in configuration file 400: a “feature-name”, “version” of the feature, “description” of the feature, source identification (“source-id”), “source-version”, “tags”, “authors”, “owners”, “watchers”, “ttl-in-milli”, “classification”, “feature-value-data-type”, “is-nullable”, “start-execution”, “is-test”, “entity-key”, “entity-value-column”, “feature-value-column”, “feature-space-name”, “calculator”, “is-aggregate”, “governance-id-mapping”, and “governance-exempted”. In some cases, the definitions of the feature can include more than one value, such as “authors”, “owners”, and “watchers”. For example, as depicted in the example configuration file 400, “authors” includes “j doe” and “j smith”.
In some cases, the configuration file 400 of the processing artifact can define additional parameters specific to stateful featurization. For example, the configuration file 400 can include a time parameter for the period of time associated with the stateful feature (e.g., a start time and end time for retrieving event data and generating feature data). In other cases, the configuration file of the processing artifact can include stateful feature data for generation other types of feature data (e.g., hierarchical features). For example, when the transformation by the feature management platform begins to consume feature outputs, as a result, other feature spaces (e.g., such as hierarchical features) can be defined as an input in the configuration file.
Example Method of the Feature Management Platform
FIG. 5 depicts an example method 500 of the feature management platform, as described with respect to FIGS. 1-4.
At step 502, the feature management platform receives (e.g., at a feature registry) a processing artifact that defines a feature associated with a corresponding data source and a transform. The processing artifact can include a configuration file and/or a code fragment. In some cases, the feature management platform can receive the processing artifact via a request from a computing device associated with the feature management platform. For example, the processing artifact can be received prior to a request for feature data or subsequent to a determination that the feature does not exist at the feature management platform.
In each instance a request is received by the feature management platform, a determination is made whether the feature exists in the feature registry of the feature management platform. In the case where the requested feature exists, the feature management platform transmits the feature (e.g., the vector) to the computing device, as described further in FIG. 6. In the case where the requested feature does not exist, the method proceeds to step 504.
At step 504, the feature management platform generates, based on the processing artifact, a processing job configured to retrieve event data from the data source. For example, the processing job can retrieve event data at a scheduled time or as a continuous data flow. In some cases, the event data is retrieved from a streaming data source. In other cases, the event data is retrieved from a batch data source.
At step 506, the feature management platform initiates the processing job. In doing so, the feature management platform retrieves the event data from the corresponding data source, applies the transform to the event data to generate a set of feature values, and encapsulates the set of feature values within a feature vector (or tensor). In some cases, the feature vector is stored in a feature store (e.g., via a message bus to a fast retrieval database and/or a training data database associated with the feature management platform) of the feature management platform. The feature vector is representative of the set of feature values. In some cases, the feature vectors are transmitted to a feature queue. For example, the feature queue can be a write path to a multi-storage persistent layer. Additionally, the metadata associated with the feature vector can be stored in the feature registry.
At step 508, the feature management platform transmits the feature vector to a model hosted on the computing device. In some cases, the feature vector is a single vector that includes the set of feature values and is transmitted as a message to the computing device.
At step 510, the feature management platform receives from the computing device, a prediction generated by the model. In some cases after the computing device receives the feature vector, the computing device initiates the model that is hosted on the computing device to generate a prediction.
At step 512, after receiving the prediction from the computing device, the feature management platform can transmit the metadata of the prediction to a feature registry and the actual value(s) of the prediction to the feature store (e.g., a fast retrieval database and/or a training data database).
In some cases, after the prediction is transmitted to the feature store, other computing devices and/or models that are connected to the feature management platform can retrieve (or “pull”) the set of features (e.g., the vector) and/or the prediction, which is an example of the shareable, discoverable, and reusability nature associated with the feature management platform. For example, a feature management platform can receive a request from a computing device for a prediction. The feature management platform can determine whether the prediction exists and if so, provide the prediction to the computing device. If the prediction does not exists, the feature management platform can provide a notification to the computing device indicating as such.
In other cases, the feature management platform can “push” a feature and/or prediction to other computing devices and/or models. For example, the feature management platform can notify connected computing devices of the availability of a feature and/or prediction. In another example, if the computing device has previously retrieved a feature and/or prediction, the feature management platform can “push” any updated feature data and/or predictions to the computing device and/or model. In such cases, the feature data and/or predictions can be pushed based on previous authorization given to the feature management platform to do so.
In some cases, the prediction generated by a first model can be used as input (or feature data) to a second model. For example, the second model can be a hosted locally on a computing device connected to the feature management platform or a downstream computing device.
Example Method of the Feature Management Platform Interactions with Computing Devices
FIG. 6 depicts an example method 600 of the feature management platform, as described with respect to FIGS. 1-5.
At step 602, the feature management platform receives, from a first computing device, a request for a feature.
At step 604, the feature management platform determines whether a feature store of the feature management platform includes the requested feature.
At step 606, the feature management platform provides a feature vector corresponding to the feature requested to a second computing device, which locally hosts a model.
At step 608, the feature management platform receives from the second computing device a prediction generated by the local model of the second computing device, based on the feature vector.
At step 610, the feature management platform updates the feature registry and feature store of the feature management platform, based on the prediction received. For example, the metadata of the prediction can be included in a feature registry while the value(s) of the prediction are included in a feature store (e.g., a fast retrieval database and/or a training data database).
In some cases, when a third computing device requests the same feature and/or prediction, the third computing device receives the feature and/or prediction from the feature management platform. In such cases, the third computing device can implement or train a locally hosted model with the feature and/or prediction as an input feature.
Example Server for a Feature Management Platform
FIG. 7 depicts an example server 700 that may perform the methods described herein, for example, with respect to FIGS. 1-3, 5, 6. For example, the server 700 can be a physical server or a virtual (e.g., cloud) server and is not limited to a single server that performs the methods described herein, for example, with respect to FIGS. 1-3, 5, 6.
Server 700 includes a central processing unit (CPU) 702 connected to a data bus 712. CPU 702 is configured to process computer-executable instructions, e.g., stored in memory 714 or storage 716, and to cause the server 700 to perform methods described herein, for example with respect to FIGS. 1-3, 5, 6. CPU 702 is included to be representative of a single CPU, multiple CPUs, a single CPU having multiple processing cores, and other forms of processing architecture capable of executing computer-executable instructions.
Server 700 further includes input/output (I/O) device(s) 708 and interfaces 704, which allows server 700 to interface with input/output devices 708, such as, for example, keyboards, displays, mouse devices, pen input, and other devices that allow for interaction with server 700. Note that server 700 may connect with external I/O devices through physical and wireless connections (e.g., an external display device).
Server 700 further includes network interface 710, which provides server 700 with access to external network 706 and thereby external computing devices.
Server 700 further includes memory 714, which in this example includes a receiving module 718, a generating module 720, an initiating module 722, a transmitting module 724, a determining module 726, and an updating module 728 for performing operations described in FIGS. 1-3, 5, 6.
Note that while shown as a single memory 714 in FIG. 7 for simplicity, the various aspects stored in memory 714 may be stored in different physical memories, but all accessible by CPU 702 via internal data connections such as bus 712.
Storage 716 further includes feature data 730, which may be like the feature data (or feature values) as generated by implementing feature logic calculations, feature metadata, stateful features, stateless features, etc., as described in FIGS. 1-3, 5, 6.
Storage 716 further includes configuration data 732, which may include the configuration file, as described in FIGS. 1-6.
Storage 716 further includes feature vector data 734, which may include vectors representing features, as described in FIGS. 1-3, 5, 6.
Storage 716 further includes prediction data 736, which may include prediction(s) received from a computing device that locally implemented a model with features (e.g., vectors) received from the feature management platform, as described in FIGS. 1-3, 5, 6.
Storage 716 further includes code fragment data 738, which may include code fragment data that is received by the feature management platform (e.g., with the configuration file), as described in FIGS. 1-3, 5, 6.
While not depicted in FIG. 7, other aspects may be included in storage 716.
As with memory 714, a single storage 716 is depicted in FIG. 7 for simplicity, but various aspects stored in storage 716 may be stored in different physical storages, but all accessible to CPU 702 via internal data connections, such as bus 712, or external connection, such as network interfaces 704. One of skill in the art will appreciate that one or more elements of server 700 may be located remotely and accessed via a network 706.
Example Method of a Computing Device Interacting with a Feature Management Platform
FIG. 8 depicts an example method 800 of the computing device interacting with the feature management platform, as described with respect to FIGS. 1-2, 5, 6.
At step 802, the computing device generates a configuration file. The configuration file can define a feature for the feature management platform, including a data source to retrieve event data from, the type of transform (or calculation) to perform on the event data, etc.
For example, the configuration file can be an object notation or data serialization configuration file format, such as a JSON file, a HOCON file, an XML file, a YAML file, a ZIP file, a JAR file, and so forth. In some cases, the computing device generates code fragments to include with the configuration file. The code fragments can include context data of the feature data to be generated. In some cases, the feature management platform may have received the code fragment previously from another computing device.
At step 804, the computing device transmits the configuration file to a feature management platform to generate the feature. In the instance that code fragments are generated, the computing device can transmit the code fragments with the configuration file as part of a processing artifact.
At step 806, the computing device receives the feature from the feature management platform. In some cases, the computing device that transmitted the configuration file (and the code fragments) can receive the feature. In other cases, the computing device that transmitted the configuration file (and the code fragments) can direct the feature management platform to transmit the feature to either the same computing device or another computing device. In some cases, the feature received from the feature management platform can be a single vector message that includes a feature vector representing the feature.
At step 808, the computing device implements a locally hosted model with the feature. In some cases, a computing device can use the feature received from the feature management platform to generate a prediction. In other cases, the computing device can use the feature to train a locally hosted model.
At step 810, the computing device can generate a prediction based on implementing the locally hosted model.
At step 812, the computing device can transmit the prediction generated to the feature management platform. In some cases, a different computing device can request the same prediction transmitted at step 812. In such cases, the feature management platform can transmit the prediction to the different computing device, without having to expend additional resources to generate the prediction.
Example Computing Device
FIG. 9 depicts an example computing device 900 that may perform the methods described herein, for example, with respect to FIGS. 1-2, 5, 6, 8. For example, the computing device 900 can be a computer, laptop, tablet, smartphone, a virtual machine, container, or other computing device with the same or similar capabilities (e.g., that includes training and implementing models as well as serving predictions to applications running on such computing device). The methods described herein, for example, with respect to FIGS. 1-2, 5, 6, 8 can be performed by one or more computing devices 900 connected to the feature management platform.
Computing device 900 includes a central processing unit (CPU) 902 connected to a data bus 912. CPU 902 is configured to process computer-executable instructions, e.g., stored in memory 914 or storage 916, and to cause the computing device 900 to perform methods described herein, for example with respect to FIGS. 1-2, 5, 6, 8. CPU 902 is included to be representative of a single CPU, multiple CPUs, a single CPU having multiple processing cores, and other forms of processing architecture capable of executing computer-executable instructions.
Computing device 900 further includes input/output (I/O) device(s) 908 and interfaces 904, which allows computing device 900 to interface with input/output devices 908, such as, for example, keyboards, displays, mouse devices, pen input, and other devices that allow for interaction with computing device 900. Note that computing device 900 may connect with external I/O devices through physical and wireless connections (e.g., an external display device).
Computing device 900 further includes network interface 910, which provides computing device 900 with access to external network 906 and thereby external computing devices.
Computing device 900 further includes memory 914, which in this example includes a receiving module 918, a generating module 920, a transmitting module 922, an implementing module 924, and a trained model 926 for performing operations described in FIGS. 1-2, 5, 6, 8.
Note that while shown as a single memory 914 in FIG. 9 for simplicity, the various aspects stored in memory 914 may be stored in different physical memories, but all accessible by CPU 902 via internal data connections such as bus 912.
Storage 916 further includes configuration data 928, which may be like the configuration file, as described in FIGS. 1-2, 4-6, 8.
Storage 916 further includes feature vector data 930, which may include the vector representing the feature, as described in FIGS. 1-2, 5, 6, 8.
Storage 916 further includes prediction data 932, which may include prediction(s) generated by a computing device that locally implemented a model with features (e.g., vectors) received from the feature management platform, as described in FIGS. 1-2, 5, 6, 8.
Storage 916 further includes code fragment data 934, which may include code fragment data that is generated by the computing device and provided to the feature management platform, as described in FIGS. 1-2, 5, 6, 8.
While not depicted in FIG. 9, other aspects may be included in storage 916.
As with memory 914, a single storage 916 is depicted in FIG. 9 for simplicity, but various aspects stored in storage 916 may be stored in different physical storages, but all accessible to CPU 902 via internal data connections, such as bus 912, or external connection, such as network interfaces 904. One of skill in the art will appreciate that one or more elements of computing device 900 may be located remotely and accessed via a network 906.
Additional Considerations
The preceding description is provided to enable any person skilled in the art to practice the various embodiments described herein. The examples discussed herein are not limiting of the scope, applicability, or embodiments set forth in the claims. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments. For example, changes may be made in the function and arrangement of elements discussed without departing from the scope of the disclosure. Various examples may omit, substitute, or add various procedures or components as appropriate. For instance, the methods described may be performed in an order different from that described, and various steps may be added, omitted, or combined. Also, features described with respect to some examples may be combined in some other examples. For example, an apparatus may be implemented or a method may be practiced using any number of the aspects set forth herein. In addition, the scope of the disclosure is intended to cover such an apparatus or method that is practiced using other structure, functionality, or structure and functionality in addition to, or other than, the various aspects of the disclosure set forth herein. It should be understood that any aspect of the disclosure disclosed herein may be embodied by one or more elements of a claim.
As used herein, a phrase referring to “at least one of” a list of items refers to any combination of those items, including single members. As an example, “at least one of: a, b, or c” is intended to cover a, b, c, a-b, a-c, b-c, and a-b-c, as well as any combination with multiples of the same element (e.g., a-a, a-a-a, a-a-b, a-a-c, a-b-b, a-c-c, b-b, b-b-b, b-b-c, c-c, and c-c-c or any other ordering of a, b, and c).
As used herein, the term “determining” encompasses a wide variety of actions. For example, “determining” may include calculating, computing, processing, deriving, investigating, looking up (e.g., looking up in a table, a database or another data structure), ascertaining and the like. Also, “determining” may include receiving (e.g., receiving information), accessing (e.g., accessing data in a memory) and the like. Also, “determining” may include resolving, selecting, choosing, establishing and the like.
The methods disclosed herein comprise one or more steps or actions for achieving the methods. The method steps and/or actions may be interchanged with one another without departing from the scope of the claims. In other words, unless a specific order of steps or actions is specified, the order and/or use of specific steps and/or actions may be modified without departing from the scope of the claims. Further, the various operations of methods described above may be performed by any suitable means capable of performing the corresponding functions. The means may include various hardware and/or software component(s) and/or module(s), including, but not limited to a circuit, an application specific integrated circuit (ASIC), or processor. Generally, where there are operations illustrated in figures, those operations may have corresponding counterpart means-plus-function components with similar numbering.
The various illustrative logical blocks, modules and circuits described in connection with the present disclosure may be implemented or performed with a general purpose processor, a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic device (PLD), discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. A general-purpose processor may be a microprocessor, but in the alternative, the processor may be any commercially available processor, controller, microcontroller, or state machine. A processor may also be implemented as a combination of computing devices, e.g., a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors in conjunction with a DSP core, or any other such configuration.
A processing system may be implemented with a bus architecture. The bus may include any number of interconnecting buses and bridges depending on the specific application of the processing system and the overall design constraints. The bus may link together various circuits including a processor, machine-readable media, and input/output devices, among others. A user interface (e.g., keypad, display, mouse, joystick, etc.) may also be connected to the bus. The bus may also link various other circuits such as timing sources, peripherals, voltage regulators, power management circuits, and other circuit elements that are well known in the art, and therefore, will not be described any further. The processor may be implemented with one or more general-purpose and/or special-purpose processors. Examples include microprocessors, microcontrollers, DSP processors, and other circuitry that can execute software. Those skilled in the art will recognize how best to implement the described functionality for the processing system depending on the particular application and the overall design constraints imposed on the overall system.
If implemented in software, the functions may be stored or transmitted over as one or more instructions or code on a computer-readable medium. Software shall be construed broadly to mean instructions, data, or any combination thereof, whether referred to as software, firmware, middleware, microcode, hardware description language, or otherwise. Computer-readable media include both computer storage media and communication media, such as any medium that facilitates transfer of a computer program from one place to another. The processor may be responsible for managing the bus and general processing, including the execution of software modules stored on the computer-readable storage media. A computer-readable storage medium may be coupled to a processor such that the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor. By way of example, the computer-readable media may include a transmission line, a carrier wave modulated by data, and/or a computer readable storage medium with instructions stored thereon separate from the wireless node, all of which may be accessed by the processor through the bus interface. Alternatively, or in addition, the computer-readable media, or any portion thereof, may be integrated into the processor, such as the case may be with cache and/or general register files. Examples of machine-readable storage media may include, by way of example, RAM (Random Access Memory), flash memory, ROM (Read Only Memory), PROM (Programmable Read-Only Memory), EPROM (Erasable Programmable Read-Only Memory), EEPROM (Electrically Erasable Programmable Read-Only Memory), registers, magnetic disks, optical disks, hard drives, or any other suitable storage medium, or any combination thereof. The machine-readable media may be embodied in a computer-program product.
A software module may comprise a single instruction, or many instructions, and may be distributed over several different code segments, among different programs, and across multiple storage media. The computer-readable media may comprise a number of software modules. The software modules include instructions that, when executed by an apparatus such as a processor, cause the processing system to perform various functions. The software modules may include a transmission module and a receiving module. Each software module may reside in a single storage device or be distributed across multiple storage devices. By way of example, a software module may be loaded into RAM from a hard drive when a triggering event occurs. During execution of the software module, the processor may load some of the instructions into cache to increase access speed. One or more cache lines may then be loaded into a general register file for execution by the processor. When referring to the functionality of a software module, it will be understood that such functionality is implemented by the processor when executing instructions from that software module.
The following claims are not intended to be limited to the embodiments shown herein, but are to be accorded the full scope consistent with the language of the claims. Within a claim, reference to an element in the singular is not intended to mean “one and only one” unless specifically so stated, but rather “one or more.” Unless specifically stated otherwise, the term “some” refers to one or more. No claim element is to be construed under the provisions of 35 U.S.C. § 112(f) unless the element is expressly recited using the phrase “means for” or, in the case of a method claim, the element is recited using the phrase “step for.” All structural and functional equivalents to the elements of the various aspects described throughout this disclosure that are known or later come to be known to those of ordinary skill in the art are expressly incorporated herein by reference and are intended to be encompassed by the claims. Moreover, nothing disclosed herein is intended to be dedicated to the public regardless of whether such disclosure is explicitly recited in the claims.

## Claims

1. A method, comprising:
receiving, at a feature management platform from a first computing device, a processing artifact that defines a feature associated with a data source and a transform;
generating, based on the processing artifact, a processing job configured to retrieve event data from the data source;
initiating the processing job that includes:
retrieving the event data from the data source;
applying the transform to the event data to generate a set of feature values; and
encapsulating the set of feature values within a feature vector for the feature to store in a feature store of the feature management platform;

storing the feature vector in the feature store for a certain amount of time, wherein the feature store is a fast-retrieval database, and wherein the feature management platform is associated with a dual storage system comprising the fast-retrieval database for storing features for the certain amount of time and a separate training data database for storing respective features for longer than the certain amount of time;
storing feature metadata associated with the feature vector in a feature registry;
transmitting the feature vector representing the set of feature values to a model hosted on the first computing device;
receiving, at the feature management platform, from the first computing device, a prediction generated by the model;
transmitting, by the feature management platform, the prediction to the feature store of the feature management platform; and
upon receiving a request from a second computing device for the feature within the certain amount of time after the storing of the feature vector in the feature store:
determining that the feature vector for the feature is stored in the fast-retrieval database of the dual storage system based on locating the feature metadata in the feature registry;
retrieving the feature vector from the fast-retrieval database based on the locating of the feature metadata in the feature registry; and
transmitting the feature vector to the second computing device from the fast-retrieval database without repeating, in response to the request, the retrieving of the event data, the applying of the transform, or the encapsulating of the set of feature values that were earlier performed to create the feature vector.

2. The method of claim 1, further comprising:
receiving a request from the first computing device for the feature; and
determining the feature is not present in the feature store.

3. The method of claim 1, further comprising:
storing the prediction in the feature store;
receiving a request from another computing device for the prediction; and
transmitting the prediction to the other computing device.

4. The method of claim 1, further comprising retrieving, based on the processing artifact, the event data from a batch data source.

5. The method of claim 1, further comprising retrieving, based on the processing artifact, the event data from a streaming data source.

6. The method of claim 1, further comprising transmitting via an API of the feature management platform to the first computing device, an interface configured to receive an indication of a type of transform that is to be applied to the event data.

7. The method of claim 1, wherein initiating the processing job includes:
implementing an aggregation operation to generate a set of aggregated feature values;
generating a stateful feature based on the set of aggregated feature values; and
encapsulating the stateful feature in a feature vector.

8. The method of claim 1, further comprising transmitting the feature vector to a feature queue, wherein the feature queue is a write path to a multi-storage persistent layer in the feature management platform.

9. The method of claim 1, wherein the processing artifact includes a configuration file and a code fragment.

10. A system, comprising:
a processor; and
a memory storing instructions, which when executed by the processor perform a method comprising:
receiving, at a feature management platform from a first computing device, a processing artifact that defines a feature associated with a data source and a transform;
generating, based on the processing artifact, a processing job configured to retrieve event data from the data source;
initiating the processing job that includes:
retrieving the event data from the data source;
applying the transform to the event data to generate a set of feature values; and
encapsulating the set of feature values within a feature vector for the feature to store in a feature store of the feature management platform;

storing the feature vector in the feature store, for a certain amount of time, wherein the feature store is a fast-retrieval database, and wherein the feature management platform is associated with a dual storage system comprising the fast-retrieval database for storing features for the certain amount of time and a separate training data database for storing respective features for longer than the certain amount of time;
storing feature metadata associated with the feature vector in a feature registry;
transmitting the feature vector representing the set of feature values to a model hosted on the first computing device;
receiving, at the feature management platform, from the first computing device, a prediction generated by the model;
transmitting, by the feature management platform, the prediction to the feature store of the feature management platform; and
upon receiving a request from a second computing device for the feature within the certain amount of time after the storing of the feature vector in the feature store:
determining that the feature vector for the feature is stored in the fast-retrieval database of the dual storage system based on locating the feature metadata in the feature registry;
retrieving the feature vector from the fast-retrieval database based on the locating of the feature metadata in the feature registry; and
transmitting the feature vector to the second computing device from the fast-retrieval database without repeating, in response to the request, the retrieving of the event data, the applying of the transform, or the encapsulating of the set of feature values that were earlier performed to create the feature vector.

11. The system of claim 10, wherein the method further comprises:
receiving a request from the first computing device for the feature; and
determining the feature is not present in the feature store.

12. The system of claim 10, wherein the method further comprises:
storing the prediction in the feature store;
receiving a request from another computing device for the prediction; and
transmitting the prediction to the other computing device.

13. The system of claim 10, wherein the method further comprises retrieving, based on the processing artifact, the event data from a batch data source.

14. The system of claim 10, wherein initiating the processing job includes:
implementing an aggregation operation to generate a set of aggregated feature values;
generating a stateful feature based on the set of aggregated feature values; and
encapsulating the stateful feature in a feature vector.

15. The system of claim 10, wherein the method further comprises transmitting via an API of the feature management platform to the first computing device, an interface configured to receive an indication of a type of transform that is to be applied for application of the transform to the event data.

16. The system of claim 10, wherein the feature defined in the processing artifact includes hierarchical feature data.

17. The system of claim 10, wherein the method further comprises transmitting the feature vector to a feature queue, wherein the feature queue is a write path to a multi-storage persistent layer.

18. The system of claim 10, wherein the processing artifact includes a configuration file and a code fragment.

19. A method, comprising:
receiving, at a feature management platform from a first computing device, a request for a feature;
determining that a feature store of the feature management platform includes the feature based on locating feature metadata that is associated with the feature in a feature registry, wherein the feature store is a fast-retrieval database, wherein the feature management platform is associated with a dual storage system comprising the fast-retrieval database for storing features for a certain amount of time and a separate training data database for storing respective features for longer than the certain amount of time, and wherein the request was received within the certain amount of time after the feature was stored in the feature store;
retrieving a feature vector of the feature from the fast-retrieval database on the locating of the feature metadata in the feature registry, and
transmitting the feature vector to a second computing device that hosts a model without repeating, in response to the request, a plurality of processing tasks that were earlier performed to create the feature vector;
receiving, the feature management platform, from the second computing device, a prediction generated by the model, based on the feature vector;
updating, by the feature management platform, the feature store based on the prediction;
transmitting the prediction to the feature store of the feature management platform; and
upon receiving a request from a third computing device for the prediction, transmitting the prediction to the third computing device from the feature store without regenerating the prediction based on the request from the third computing device.

20. The method of claim 19, wherein the feature metadata in the feature registry indicates that the feature vector is stored in the feature store.