Implementations of the present disclosure include methods, systems, and computer-readable storage mediums for concurrent production use of an application and training of a modified application. Actions include receiving a change request that provides at least one application change for an application executed by a production system, retrieving, from the production system, a portion of production data associated to the at least one application change, executing training of a model of the application using the one or more production data to generate a trained model of the application, testing the trained model of the application to generate test results, extending the change request by adding the trained model, and providing, by the production system, the extended change request to deploy the at least one application change and the trained model to the production system.
|
8. A non-transitory computer-readable storage medium coupled to one or more processors and having instructions stored thereon which, when executed by the one or more processors, cause the one or more processors to perform operations for concurrent production use of an application and training of a modified application, the operations comprising:
receiving a change request that provides at least one application change for an application executed by a production system;
retrieving, from the production system, a portion of production data associated to the at least one application change;
executing training of a model of the application using the portion of production data to generate a trained model of the application;
testing the trained model of the application to generate test results;
generating an extended change request comprising the trained model; and
providing, by the production system, the extended change request to deploy the at least one application change and the trained model to the production system.
1. A computer-implemented method for concurrent production use of an application and training of a modified application, the method being executed using one or more processors and comprising:
receiving, by the one or more processors, a change request that provides at least one application change for an application executed by a production system;
retrieving, by the one or more processors from the production system, a portion of production data associated to the at least one application change;
executing, by the one or more processors, training of a model of the application using the portion of production data to generate a trained model of the application;
testing, by the one or more processors, the trained model of the application to generate test results;
generating, by the one or more processors, based on the test results an extended change request comprising the trained model; and
providing, by the one or more processors to the production system, the extended change request to deploy the at least one application change and the trained model to the production system.
15. A computer-implemented system, comprising:
a client-side computing device; and
a computer-readable storage device coupled to the client-side computing device and having instructions stored thereon which, when executed by the client-side computing device, cause the client-side computing device to perform operations for concurrent production use of an application and training of a modified application, the operations comprising:
receiving a change request that provides at least one application change for an application executed by a production system;
retrieving, from the production system, a portion of production data associated to the at least one application change;
executing training of a model of the application using the portion of production data to generate a trained model of the application;
testing the trained model of the application to generate test results;
generating an extended change request by adding the trained model; and
providing, by the production system, the extended change request to deploy the at least one application change and the trained model to the production system.
2. The computer-implemented method of
3. The computer-implemented method of
4. The computer-implemented method of
5. The computer-implemented method of
6. The computer-implemented method of
7. The computer-implemented method of
determining, by the one or more processors, an accuracy of the trained model of the application;
comparing, by the one or more processors, the accuracy to a set threshold; and
in response to determining that the accuracy exceeds the set threshold, testing, by the one or more processors, the trained model of the application to generate test results.
9. The non-transitory computer-readable storage medium of
10. The non-transitory computer-readable storage medium of
11. The non-transitory computer-readable storage medium of
12. The non-transitory computer-readable storage medium of
13. The non-transitory computer-readable storage medium of
14. The non-transitory computer-readable storage medium of
determining an accuracy of the trained model of the application;
comparing the accuracy to a set threshold; and
in response to determining that the accuracy exceeds the set threshold, testing the trained model of the application to generate test results.
16. The computer-implemented system of
17. The computer-implemented system of
18. The computer-implemented system of
19. The computer-implemented system of
20. The computer-implemented system of
|
|||||||||||||||||||||||||
The training of a model needs access to production data. A typical development-test-production landscape does not contain production data from a production system in a development system. Depending on database volume and costs, sometimes production data is also not contained in a test system. The development system and the test system typically contain a subset of the production data or sample production data. The lack of access to production data leads to a problem—that a “model” cannot be trained with data typically stored in the development system or the test system. Test-data-replication concepts are available for defining which data to replicate (and encrypt). Test-data-replication concepts can be useful to develop a new model, but for the fact that training of a model to be deployed to the production system requires the production data. The duplication of production data to the development system or the test system increases the database size of these systems, which can lead to additional computing resource needs and increased costs.
The present disclosure describes methods and systems, including computer-implemented methods, computer program products, and computer systems for training applications.
In an implementation, a change request that provides at least one application change for an application executed by a production system is received. A portion of production data associated to the at least one application change is retrieved from the production system. A training of a model of the application using the one or more production data to generate a trained model of the application is executed. The trained model of the application is tested to generate test results. An extended change request including the trained model is generated based on the test results. The extended change request is provided to deploy the at least one application change and the trained model to the production system.
Implementations of the described subject matter, including the previously described implementation, can be implemented using a computer-implemented method; a non-transitory, computer-readable medium storing computer-readable instructions to perform the computer-implemented method; and a computer-implemented system comprising one or more computer memory devices interoperably coupled with one or more computers and having tangible, non-transitory, machine-readable media storing instructions that, when executed by the one or more computers, perform the computer-implemented method/the computer-readable instructions stored on the non-transitory, computer-readable medium.
The subject matter described in this specification can be implemented so as to realize one or more of the following advantages. First, implementations of the present disclosure include a modification of a system configuration to provide data for a model to train in an environment, where a change is created, thereby reducing errors, as well as reducing an amount of maintenance (for example, human input). In some examples, maintenance can be reduced by triggering automated procedures to setup and delete models for a test and a training environment, and to transport the model to the test environment. Second, modified enterprise systems can be tested using the model, which is based on production data (for example, actual customer data). In this manner, testing can accurately reflect production data use in the modified enterprise system. Third, not all production data is copied for testing. Using the described implementation enables time and resource management, such that a need to copy and store large amounts of data (for example, terabytes (TB) in one or more databases) is foregone. Fourth, production data of a production enterprise system can be concurrently maintained with that of a modified enterprise system, resulting in little to no downtime experienced by users of the production enterprise system. Fifth, a newly configured process using a model can be switched on by modifying the configuration data and deploying a trained model in one step, thus avoiding inconsistent configurations.
The details of one or more implementations of the subject matter of this specification are set forth in the Detailed Description, the Claims, and the accompanying drawings. Other features, aspects, and advantages of the subject matter will become apparent to those of ordinary skill in the art from the Detailed Description, the Claims, and the accompanying drawings.
Like reference numbers and designations in the various drawings indicate like elements.
Implementations of the present disclosure are generally directed to training and testing modified enterprise systems without disturbing a corresponding production enterprise system. More specifically, implementations of the present disclosure are directed to testing updates to or customization of an enterprise system using a re-trainable model based on data in a production environment. Various modifications, alterations, and permutations of the disclosed implementations can be made and will be readily apparent to those of ordinary skill in the art, and the general principles defined can be applied to other implementations and applications, without departing from the scope of the present disclosure. In some instances, one or more technical details that are unnecessary to obtain an understanding of the described subject matter and that are within the skill of one of ordinary skill in the art may be omitted so as to not obscure one or more described implementations. The present disclosure is not intended to be limited to the described or illustrated implementations, but to be accorded the widest scope consistent with the described principles and features.
A system configured for learning applications can define or use a model for the data input that provides, for example, a digital representative of production data. A new version of an application can have a new definition of data structures and formats.
Conventional approaches for machine learning mechanisms can require access to production data. Typically, production data is not available in development or test systems. To overcome the lack of production data availability within a test system, test-data-replication concepts are available for defining, which data to replicate (and encrypt). The test-data-replication concepts can be useful to develop a new model, but for the fact that training of a model to be deployed to a production system requires the production data. Even if no restrictions would be imposed on production data accessibility, duplication of production data to development and test systems increases database size of these systems, which can lead to additional computing resource needs and increased costs. As an example, the training can require additional hardware capabilities (such as, a GPU), which again increases hardware costs. Training in production can also directly lead to performance degradation of an application, as the training can be a very hardware intense operation.
However, using techniques described in the present disclosure, a change management landscape and a change management process can be extended to support software artifacts, which are created out of production data and whose creation takes a considerable portion of available resources and time. The described implementation can prevent the need to duplicate production data and enables re-training of the model for the testing system. For example, upon deployment of a change request (for example, new software, new content, or new model software and configuration), created in a development system to a test system, a trained model is created. The change management landscape is extended by a “training system,” which is only required temporarily, and which can be deployed on dedicated “training hardware.” In some implementations, the training system can be shared among multiple systems (for example, day 1 for system 1, day 2 for system 2, and so on).
In some implementations, the model is accompanied by metadata defining which data is read during the training. The portion of production data indicated as necessary for training is replicated from the production system to the training system. The new configuration data is deployed to the training system. The new model software and configuration can be deployed to the training system. In response to deployment, the training is started and a “trained model” is created.
The training is de-coupled from the production system, as training resource usage does not impact the production system. Specialized hardware can be used for testing and training. During a training process, the application can continue to execute in the production system (that is, using an “old” active model).
The “trained model” can be tested together with the change request in the test system. The trained model can be retrieved from the training system to the test system. The trained model is deployed in the test system (for example, depending on a required runtime environment). The process change can be tested in the testing environment by the test system. The test results can be assessed by the test system. In response to determining that the test results include failed tests, the change request can be modified in the development system, deployed in an extended version to test, and the training can be repeated until failed tests are eliminated. The “trained model” can then be added to the change request. The extended change request (for example, new software, new content, new model software and configuration) can be extended by a “trained model.” In some implementations, the extended change request can be deployed to the production system. The deployment to the production system can include transmitting: a new software, a new content, a new model software, a new configuration, and a new trained model. After deployment, the complete change of the process can be immediately active in production system.
In some implementations, the database system 106b is provided as an in-memory database system. In some examples, an in-memory database is a database management system that uses main memory for data storage. In some examples, main memory includes random access memory (RAM) that communicates with one or more processors (for example, central processing units (CPUs)) over a memory bus. An-memory database can be contrasted with database management systems that employ a disk storage mechanism. In some examples, in-memory databases are faster than disk storage databases, because internal optimization algorithms can be simpler and execute fewer CPU instructions (for example, require reduced CPU consumption). In some examples, accessing data in an in-memory database eliminates seek time when querying the data, which provides faster and more predictable performance than disk-storage database systems.
In some examples, the network 108 can be a public communication network (for example, the Internet, cellular data network, dialup modems over a telephone network), a wide area network (WAN), a local area network (LAN), a private communications network (for example, private LAN, leased lines), or any appropriate combination thereof.
In accordance with implementations of the present disclosure, the back-end system 106 can host one or more enterprise systems. In some examples, an enterprise system can be provided as one or more computer-executable programs executed by one or more computing devices. Example enterprise systems can include an enterprise resource planning (ERP) system, a client-relationship management (CRM) system, a product lifecycle management (PLM) system, a supply chain management (SCM) system, and supplier relationship management (SRM) system.
In some implementations, an enterprise system can be provided in a production mode, during which users interact with the enterprise system to access functionality provided by the enterprise system, access data through the enterprise system, or generate/modify data using the enterprise system. During operation in the production mode, data that is accessed/generated/modified can be referred to as production data. In other words, production data is data that is accessed/generated/modified during real-world execution of the system.
In an example, the users 110a, 110b can be employees of an enterprise, which uses an enterprise system hosted on the back-end system 106 for operations. For example, the user 110a can use the client device 102a to interact with the enterprise system and access production data (for example, access a customer profile) stored at the back-end system 106. As another example, the user 110b can use the client device 102b to interact with the enterprise system and generate production data (for example, create a new customer profile) that is stored at the back-end system 106. In some examples, data is read from and written to the database system 106b during production use of the enterprise system.
In some implementations, after the enterprise system has been operating in the production mode, a modification to the enterprise system may be required. For example, the enterprise system can be updated (for example, update from an earlier version to a newer version) or customized (for example, implement custom features for a particular entity). Consequently, a modified enterprise system can be provided, which includes one or more modifications (for example, updates or customizations). In some examples, the modified enterprise system can be operated in a test mode to test the modifications. In some examples, testing of the modified enterprise system is performed using production data. In this manner, it can be confirmed that the modified enterprise system functions as intended with the production data before transitioning from the test mode to the production mode. In some implementations, the user 112 (for example, an administrator of the enterprise system) can use the client device 104 to perform testing of the modified enterprise system, as described in further detail herein.
As introduced above, implementations of the present disclosure enable testing of a modified enterprise system using production data. More particularly, implementations of the present disclosure enable training and testing of a model of a modified enterprise system using production data, while the enterprise system (for example, unmodified enterprise system) continues to operate in the production mode. In accordance with implementations of the present disclosure, and as described in further detail herein, a production database schema and a training database schema are provided. In some examples, a database schema is a structure that is supported by a database management system (DBMS) and refers to the organization of data stored in the database. The database schema, for example, logically groups items (for example, tables, views, or stored procedures). In some examples, a user (for example, the user 110a, 110b, 112) can be assigned permissions to a respective database schema, such that the user can only access the objects they are authorized to access.
In accordance with implementations of the present disclosure, the production database schema defines the logical groupings of objects for the database (for example, the database 106b), when the enterprise system is operating in the production mode. The training database schema defines the logical groupings of objects for the database (for example, the database 106b), when the modified enterprise system is operating in the test and training mode. In some examples, interactions of users (for example, the user 110a, 110b) during model training using production data of the enterprise system, and thus the database (for example, the database 106b), can be governed by training rules. Likewise, users (for example, the user 112) testing the modified model of the application, and thereby interacting with production data stored in the database (for example, the database 106b), during the testing mode, will be governed by testing rules.
The change manager 202 can deploy the change request 212 to the test system 206. For example, at least one of the new configuration for the process, the custom code and configuration data is deployed. The test system 206 processes the change request 212 and identifies that the change request 212 includes a change to a model configuration or model software. The test system 206 sends a signal to the change manager 202 indicating that training is required.
The change manager 202 can deploy a relevant portion of the change request 212 to the training system 208. The relevant portion of the change request 212 can include a request to add a new model configuration, to modify (for example, add or delete a portion of) the configuration data, or the model software.
The change manager 202 can retrieve relevant data from production system 210 and trigger its transmission to the training system 208. For example, the model configuration indicates which production data is processed by the training system 208 during training (for example, specifying a set of database views or tables). The indicated data is retrieved from production system 210 and transmitted to the training system 208. The transmission of the indicated data can be a “delta data transfer”. For example, if some of the data is already stored by the training system 208, or an older version of the data is available, only the remaining data (for example, new data or data with data formats different from pre-stored (or cached) data) is transmitted. The data load can include configuration data. The data transmitted by the production system 210 to the training system 208 is merged with the data deployed through the change request. If there is an overlap, the configuration data is deployed after the load from the production system 210.
The training system 208 can be configured to process the current data and the stored data based on the defined configuration. For example, the training system 208 can execute a training of the model with the defined configuration. The training can be based on software deployed from the change request 212. The training process can generate as output a status information about achieved accuracy (for example, an accuracy score). An administrator or a key process user can assess the results of the training process and decide based on the results whether to continue the testing process or to modify the model configuration. For example, the accuracy score can be compared to an accuracy threshold and approve the trained model if the accuracy score exceeds the accuracy threshold. The change manager 202 can retrieve the approved model from the training system 208 and deploy the approved model to the test system 206.
The test system 206 is configured to process the approved model. The test system 206 processes the new configuration for the process, the new configuration data (or master data), the new custom code, and the newly trained model to generate a test result. In some implementations, the test results are automatically evaluated. For example, test errors can be classified as major, moderate and minor. In case only minor errors or no errors are generated, the test can be automatically marked as passing. In some implementations, the test results (for example, moderate or major errors) are assessed by users. If the test does not pass, a signal is sent to the development system 204 to trigger a change to be implemented in the development system 204 and the data identification, retrieval and training process can be repeated. If the test passes, the change request is extended by the trained model 214, which generates an extended change request 216. The extended change request 216 can be deployed by the change manager 202 to the production system 210. The extended change request 216 deploys in one step: the new configuration for the process, the new configuration data (or master data), the new custom code, or the newly trained model.
In some implementations, the model 214 is built on data which is written by the system. The model 214 can become “outdated”: new data can be created, which has not been read upon training of the model 214. The change manager 202 can be configured to trigger a retraining of the model 214 to prevent letting the model 214 to become outdated. In some implementations, model re-training can be performed without altering the configuration or model configuration. Model re-training can be triggered by different events: for example, a monitoring infrastructure can generate an alert that the model is degraded, a key user can trigger model re-training, a scheduler can be defined to periodically trigger model re-training or database volume changes can be monitored to trigger re-training. The model re-training process can include sending a trigger to the change manager 202 to read the scenario definition (in the metadata) of the model 214 to be re-trained. The change manager 202 can call a data transfer. The data defined in the model metadata can be replicated in the database of the training system 208 (or the delta of the data since the last data transfer). The change manager 202 can generate a signal to initiate training of the model with the new data. The training process can return a status information about achieved training accuracy. The change manager 202 can read the new version of the model 214 from training system 208 and can deploy the new version of the model 214 to the production system 210.
At 302, a change request is received. The change request can include a set of changes of different type, some types relevant to the process described here like a change to a model configuration or model software and in addition changes of the following type: like new version of code, new entries for configuration tables, new table structure definitions and the like. The change request can indicate enhancements to production data, such as one or more existing tables. For example, the modified enterprise system is based on a production enterprise system and includes updates(s) or modification(s) of the production enterprise system. In some examples, an existing table is provided as a table of the production enterprise system, and an enhancement can include, for example, a modification of the table (for example, a new column being added to the table). In some examples, if the modified enterprise system includes enhancements to one or more tables, each table that is to be enhanced is renamed. For example, the name of a table that is to be enhanced is changed from “Table” to “Table_New.” Respective views are created in a production database schema using the original table names. For example, a table view can be provided called “Table” in the production database schema. Respective structures of the one or more tables are modified and respective views can be extended in the training database schema. From 302, method 300 proceeds to 304.
At 304, a portion of the change request is transmitted. For example, the relevant portion of the change request can include a request to add a new model configuration, to modify (add or delete a portion of) the configuration data, or the model software. The change request can contain change types like new software version, new table definitions, the previously mentioned change types model configuration, and model software. In some implementations, a change request includes objects describing multiple, different single changes. The “change objects” can define a change in code, a change in table definition, or a change in table content. The change types are detected by the change request management, which are relevant for model training (like the change model configuration or model software) but not the changed table definition. In some implementations, change types include model configuration and model software. The change request containing the new change types can be detected, the respective objects of these change types are extracted and transmitted to the training system. From 304, method 300 proceeds to 306.
At 306, relevant production data are retrieved from a production system and transmitted to a training system. The transmission of the indicated data can be a “delta data transfer.” For example, if some of the data is already stored by the training system, or an older version of the data is available only the remaining data is transmitted. The data load can include configuration data. The data transmitted by the production system to the training system is merged with the data deployed through the change request. If there is an overlap, the configuration data is deployed after the load from the production system. In some implementations, during training of the modified enterprise system read-access can be requested to production data. For example, read-access is requested to the enhanced table “Table_New,” which stores production data, and the table view “Table_New” of the train database schema is used to read the production data. Further, during production use of the enterprise system, read access to the production data stored in the enhanced table “Table_New” is provided using the view “Table” of the production database schema. In this manner, the enhanced table is transparent to the production enterprise system. During training of the modified enterprise system read-access can be requested to data that is stored in a local table (for example, which corresponds to a respective production table). In some examples, a read-trigger causes data to be read from the local table and from the respective production table, and the data is merged, where, if the data from the local table has the same key as the data from the production table, the data from the local table is provided in response to the read request. During training of the modified enterprise system write-access can be requested to write data to a production table. In some examples, a write-trigger causes the data to be written (for example, as train data) to the respective local table. In some implementations, the portion of the production data includes (randomly) reformatting or scrambling the portion of the production data to maintain data privacy. From 306, method 300 proceeds to 308.
At 308, the execution of the model training is initiated at the training system by using the production data. For example, the training system can be configured to process the current data and the stored data based on the defined configuration. For example, the training system can execute a training of the model with the defined configuration. The training can be based on software deployed from the change request. The training process can generate as output a status information about achieved accuracy by comparing the training accuracy to a set threshold. An administrator or a key process user can assess the results of the training process and decide based on the results whether to continue the testing process or to modify the model configuration. For the training, a software module (the training software) is called with a set of parameters, the software module computing the model. The parameters can be changed to create different models. The training software returns a set of parameters (accuracy parameters) describing the quality of the model. Modifying input parameters to the training module can alter the accuracy. The training software can also be configured to read different sets of records from the training data set (for example, reading only data of the last month, or the last two months, or of certain key ranges). This can also impact the model accuracy. The administrator can review the accuracy, modify parameters, read data records, and chose a configuration which achieves the highest accuracy. After 308, method 300 proceeds to 310.
At 310, it is determined whether the model is approved. After 310, in response to determining that the model is not approved method 300 proceeds to 312.
At 312, an update of the change request is transmitted to the development system. After 312, method 300 returns to 302.
After 310, in response to determining that the model is approved, method 300 proceeds to 314.
At 314, the execution of the model testing is initiated at the test system by using the production data. For example, the test system processes the new configuration for the process, the new configuration data (or master data), the new custom code, and the newly trained model to generate a test result. After 314, method 300 proceeds to 316.
At 316, it is determined whether the test passes. In some implementations, the test results are automatically evaluated. In response to determining that the model does not pass the test, the method 300 returns to 302. For example, if the test does not pass, a signal can be sent to the development system to trigger a change to be implemented in the development system and the data identification, retrieval and training process can be repeated. In response to determining that the model passes the test, the method 300 proceeds to 318.
At 318, the change request is extended by the trained model of the application. From 318, method 300 proceeds to 320.
At 320, the extended change request is transmitted to the production system. The extended change request can include the original change request and at least an additional object. For example, the original change request can contain a model configuration to use a certain algorithm for training and a set of parameters to call the algorithm with. The algorithm computes the trained model (for example, a database stored procedure or a software module). The computed artifact (for example, the database stored procedure, computed software module) is added as an object to the change request to generate the extended change request. The extended change request, deployed to the production system, can include the computed database stored procedure or software module. For example, the extended change request deploys in one-step: the new configuration for the process, the new configuration data (or master data), the new custom code, and the newly trained model. After 320, method 300 can stop.
The illustrated Computer 402 is intended to encompass any computing device such as a server, desktop computer, laptop/notebook computer, wireless data port, smart phone, personal data assistant (PDA), tablet computer, one or more processors within these devices, another computing device, or a combination of computing devices, including physical or virtual instances of the computing device, or a combination of physical or virtual instances of the computing device. Additionally, the Computer 402 can include an input device, such as a keypad, keyboard, touch screen, another input device, or a combination of input devices that can accept user information, and an output device that conveys information associated with the operation of the Computer 402, including digital data, visual, audio, another type of information, or a combination of types of information, on a graphical-type user interface (UI) (or GUI) or other UI.
The Computer 402 can serve in a role in a distributed computing system as a client, network component, a server, a database or another persistency, another role, or a combination of roles for performing the subject matter described in the present disclosure. The illustrated Computer 402 is communicably coupled with a Network 430. In some implementations, one or more components of the Computer 402 can be configured to operate within an environment, including cloud computing based, local, global, another environment, or a combination of environments.
At a high level, the Computer 402 is an electronic computing device operable to receive, transmit, process, store, or manage data and information associated with the described subject matter. According to some implementations, the Computer 402 can also include or be communicably coupled with a server, including an application server, email server, web server, caching server, streaming data server, another server, or a combination of servers.
The Computer 402 can receive requests over Network 430 (for example, from a client software application executing on another Computer 402) and respond to the received requests by processing the received requests using a software application or a combination of software applications. In addition, requests can also be sent to the Computer 402 from internal users (for example, from a command console or by another internal access method), external or third parties, or other entities, individuals, systems, or computers.
Each of the components of the Computer 402 can communicate using a System Bus 403. In some implementations, any or all of the components of the Computer 402, including hardware, software, or a combination of hardware and software, can interface over the System Bus 403 using an application-programming interface (API) 412, a Service Layer 413, or a combination of the API 412 and Service Layer 413. The API 412 can include specifications for routines, data structures, and object classes. The API 412 can be either computer-language independent or dependent and refer to a complete interface, a single function, or even a set of APIs. The Service Layer 413 provides software services to the Computer 402 or other components (whether illustrated or not) that are communicably coupled to the Computer 402. The functionality of the Computer 402 can be accessible for all service consumers using the Service Layer 413. Software services, such as those provided by the Service Layer 413, provide reusable, defined functionalities through a defined interface. For example, the interface can be software written in JAVA, C++, another computing language, or a combination of computing languages providing data in extensible markup language (XML) format, another format, or a combination of formats. While illustrated as an integrated component of the Computer 402, alternative implementations can illustrate the API 412 or the Service Layer 413 as stand-alone components in relation to other components of the Computer 402 or other components (whether illustrated or not) that are communicably coupled to the Computer 402. Moreover, any or all parts of the API 412 or the Service Layer 413 can be implemented as a child or a sub-module of another software module, enterprise application, or hardware module without departing from the scope of the present disclosure.
The Computer 402 includes an Interface 404. Although illustrated as a single Interface 404, two or more Interfaces 404 can be used according to particular needs, desires, or particular implementations of the Computer 402. The Interface 404 is used by the Computer 402 for communicating with another computing system (whether illustrated or not) that is communicatively linked to the Network 430 in a distributed environment. Generally, the Interface 404 is operable to communicate with the Network 430 and includes logic encoded in software, hardware, or a combination of software and hardware. More specifically, the Interface 404 can include software supporting one or more communication protocols associated with communications such that the Network 430 or hardware of Interface 404 is operable to communicate physical signals within and outside of the illustrated Computer 402.
The Computer 402 includes a Processor 405. Although illustrated as a single Processor 405, two or more Processors 405 can be used according to particular needs, desires, or particular implementations of the Computer 402. Generally, the Processor 405 executes instructions and manipulates data to perform the operations of the Computer 402 and any algorithms, methods, functions, processes, flows, and procedures as described in the present disclosure.
The Computer 402 also includes a Database 406 that can hold data for the Computer 402, another component communicatively linked to the Network 430 (whether illustrated or not), or a combination of the Computer 402 and another component. For example, Database 406 can be an in-memory, conventional, or another type of database storing data consistent with the present disclosure. In some implementations, Database 406 can be a combination of two or more different database types (for example, a hybrid in-memory and conventional database) according to particular needs, desires, or particular implementations of the Computer 402 and the described functionality. Although illustrated as a single Database 406, two or more databases of similar or differing types can be used according to particular needs, desires, or particular implementations of the Computer 402 and the described functionality. While Database 406 is illustrated as an integral component of the Computer 402, in alternative implementations, Database 406 can be external to the Computer 402.
The Computer 402 also includes a Memory 407 that can hold data for the Computer 402, another component or components communicatively linked to the Network 430 (whether illustrated or not), or a combination of the Computer 402 and another component. Memory 407 can store any data consistent with the present disclosure. In some implementations, Memory 407 can be a combination of two or more different types of memory (for example, a combination of semiconductor and magnetic storage) according to particular needs, desires, or particular implementations of the Computer 402 and the described functionality. Although illustrated as a single Memory 407, two or more Memories 407 or similar or differing types can be used according to particular needs, desires, or particular implementations of the Computer 402 and the described functionality. While Memory 407 is illustrated as an integral component of the Computer 402, in alternative implementations, Memory 407 can be external to the Computer 402.
The Application 408 is an algorithmic software engine providing functionality according to particular needs, desires, or particular implementations of the Computer 402, particularly with respect to functionality described in the present disclosure. For example, Application 408 can serve as one or more components, modules, or applications. Further, although illustrated as a single Application 408, the Application 408 can be implemented as multiple Applications 408 on the Computer 402. In addition, although illustrated as integral to the Computer 402, in alternative implementations, the Application 408 can be external to the Computer 402.
The Computer 402 can also include a Power Supply 414. The Power Supply 414 can include a rechargeable or non-rechargeable battery that can be configured to be either user- or non-user-replaceable. In some implementations, the Power Supply 414 can include power-conversion or management circuits (including recharging, standby, or another power management functionality). In some implementations, the Power Supply 414 can include a power plug to allow the Computer 402 to be plugged into a wall socket or another power source to, for example, power the Computer 402 or recharge a rechargeable battery.
There can be any number of Computers 402 associated with, or external to, a computer system containing Computer 402, each Computer 402 communicating over Network 430. Further, the term “client,” “user,” or other appropriate terminology can be used interchangeably, as appropriate, without departing from the scope of the present disclosure. Moreover, the present disclosure contemplates that many users can use one Computer 402, or that one user can use multiple Computers 402.
Described implementations of the subject matter can include one or more features, alone or in combination.
For example, in a first implementation, a computer-implemented method, comprises: receiving a change request that provides at least one application change for an application executed by a production system, retrieving, from the production system, a portion of production data associated to the at least one application change, executing training of a model of the application using the one or more production data to generate a trained model of the application, testing the trained model of the application to generate test results, generating an extended change request including the trained model, and providing, by the production system, the extended change request to deploy the at least one application change and the trained model to the production system.
The foregoing and other described implementations can each, optionally, include one or more of the following features:
A first feature, combinable with any of the following features, wherein the portion of the production data associated to the at least one application change is smaller than a whole set of the production data.
A second feature, combinable with any of the previous or following features, wherein the portion of the production data is selected from a production database of the production system based on a comparison to old production data previously stored in a training database of the training system.
A third feature, combinable with any of the previous or following features, wherein retrieving the portion of the production data includes reformatting the portion of the production data.
A fourth feature, combinable with any of the previous or following features, wherein concurrent execution of the training of the model of the application is performed without interfering with production use of the application.
A fifth feature, combinable with any of the previous or following features, wherein the change request includes a change to at least one of a model configuration and a model software.
A sixth feature, combinable with any of the previous or following features, further including: determining an accuracy of the trained model of the application, comparing the accuracy to a set threshold, and in response to determining that the accuracy exceeds the set threshold, testing the trained model of the application to generate test results.
In a second implementation, a non-transitory computer-readable storage medium coupled to one or more processors and having instructions stored thereon which, when executed by the one or more processors, cause the one or more processors to perform operations for concurrent production use of an application and training of a modified application, the operations including: receiving a change request that provides at least one application change for an application executed by a production system, retrieving, from the production system, a portion of production data associated to the at least one application change, executing training of a model of the application using the one or more production data to generate a trained model of the application, testing the trained model of the application to generate test results, generating an extended change request including the trained model, and providing, by the production system, the extended change request to deploy the at least one application change and the trained model to the production system.
The foregoing and other described implementations can each, optionally, include one or more of the following features:
A first feature, combinable with any of the following features, wherein the portion of the production data associated to the at least one application change is smaller than a whole set of the production data.
A second feature, combinable with any of the previous or following features, wherein the portion of the production data is selected from a production database of the production system based on a comparison to old production data previously stored in a training database of the training system.
A third feature, combinable with any of the previous or following features, wherein retrieving the portion of the production data includes reformatting the portion of the production data.
A fourth feature, combinable with any of the previous or following features, wherein concurrent execution of the training of the model of the application is performed without interfering with production use of the application.
A fifth feature, combinable with any of the previous or following features, wherein the change request includes a change to at least one of a model configuration and a model software.
A sixth feature, combinable with any of the previous or following features, further including: determining an accuracy of the trained model of the application, comparing the accuracy to a set threshold, and in response to determining that the accuracy exceeds the set threshold, testing the trained model of the application to generate test results.
In a third implementation, a computer-implemented system, including: a client-side computing device, and a computer-readable storage device coupled to the client-side computing device and having instructions stored thereon which, when executed by the client-side computing device, cause the client-side computing device to perform operations for concurrent production use of an application and training of a modified application. The operations include: receiving a change request that provides at least one application change for an application executed by a production system, retrieving, from the production system, a portion of production data associated to the at least one application change, executing training of a model of the application using the one or more production data to generate a trained model of the application, testing the trained model of the application to generate test results, generating an extended change request by adding the trained model, and providing, by the production system, the extended change request to deploy the at least one application change and the trained model to the production system.
The foregoing and other described implementations can each, optionally, include one or more of the following features:
A first feature, combinable with any of the following features, wherein the portion of the production data associated to the at least one application change is smaller than a whole set of the production data.
A second feature, combinable with any of the previous or following features, wherein the portion of the production data is selected from a production database of the production system based on a comparison to old production data previously stored in a training database of the training system.
A third feature, combinable with any of the previous or following features, wherein retrieving the portion of the production data includes reformatting the portion of the production data.
A fourth feature, combinable with any of the previous or following features, wherein concurrent execution of the training of the model of the application is performed without interfering with production use of the application.
A fifth feature, combinable with any of the previous or following features, wherein the change request includes a change to at least one of a model configuration and a model software.
A sixth feature, combinable with any of the previous or following features, further including: determining an accuracy of the trained model of the application, comparing the accuracy to a set threshold, and in response to determining that the accuracy exceeds the set threshold, testing the trained model of the application to generate test results.
Implementations of the subject matter and the functional operations described in this specification can be implemented in digital electronic circuitry, in tangibly embodied computer software or firmware, in computer hardware, including the structures disclosed in this specification and their structural equivalents, or in combinations of one or more of them. Software implementations of the described subject matter can be implemented as one or more computer programs, that is, one or more modules of computer program instructions encoded on a tangible, non-transitory, computer-readable medium for execution by, or to control the operation of, a computer or computer-implemented system. Alternatively, or additionally, the program instructions can be encoded in/on an artificially generated propagated signal, for example, a machine-generated electrical, optical, or electromagnetic signal that is generated to encode information for transmission to a receiver apparatus for execution by a computer or computer-implemented system. The computer-storage medium can be a machine-readable storage device, a machine-readable storage substrate, a random or serial access memory device, or a combination of computer-storage mediums. Configuring one or more computers means that the one or more computers have installed hardware, firmware, or software (or combinations of hardware, firmware, and software) so that when the software is executed by the one or more computers, particular computing operations are performed.
The term “real-time,” “real time,” “realtime,” “real (fast) time (RFT),” “near(ly) real-time (NRT),” “quasi real-time,” or similar terms (as understood by one of ordinary skill in the art), means that an action and a response are temporally proximate such that an individual perceives the action and the response occurring substantially simultaneously. For example, the time difference for a response to display (or for an initiation of a display) of data following the individual's action to access the data can be less than 1 millisecond (ms), less than 1 second (s), or less than 5 s. While the requested data need not be displayed (or initiated for display) instantaneously, it is displayed (or initiated for display) without any intentional delay, taking into account processing limitations of a described computing system and time required to, for example, gather, accurately measure, analyze, process, store, or transmit the data.
The terms “data processing apparatus,” “computer,” or “electronic computer device” (or an equivalent term as understood by one of ordinary skill in the art) refer to data processing hardware. Data processing hardware encompass all kinds of apparatuses, devices, and machines for processing data, including by way of example, a programmable processor, a computer, or multiple processors or computers. The computer can also be, or further include special purpose logic circuitry, for example, a central processing unit (CPU), a field programmable gate array (FPGA), or an application-specific integrated circuit (ASIC). In some implementations, the computer or computer-implemented system or special purpose logic circuitry (or a combination of the computer or computer-implemented system and special purpose logic circuitry) can be hardware- or software-based (or a combination of both hardware- and software-based). The computer can optionally include code that creates an execution environment for computer programs, for example, code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of execution environments. The present disclosure contemplates the use of a computer or computer-implemented system with an operating system of some type, for example LINUX, UNIX, WINDOWS, MAC OS, ANDROID, IOS, another operating system, or a combination of operating systems.
A computer program, which can also be referred to or described as a program, software, a software application, a unit, a module, a software module, a script, code, or other component can be written in any form of programming language, including compiled or interpreted languages, or declarative or procedural languages, and it can be deployed in any form, including, for example, as a stand-alone program, module, component, or subroutine, for use in a computing environment. A computer program can, but need not, correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data, for example, one or more scripts stored in a markup language document, in a single file dedicated to the program in question, or in multiple coordinated files, for example, files that store one or more modules, sub-programs, or portions of code. A computer program can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and interconnected by a communication network.
While portions of the programs illustrated in the various figures can be illustrated as individual components, such as units or modules, that implement described features and functionality using various objects, methods, or other processes, the programs can instead include a number of sub-units, sub-modules, third-party services, components, libraries, and other components, as appropriate. Conversely, the features and functionality of various components can be combined into single components, as appropriate. Thresholds used to make computational determinations can be statically, dynamically, or both statically and dynamically determined.
Described methods, processes, or logic flows represent one or more examples of functionality consistent with the present disclosure and are not intended to limit the disclosure to the described or illustrated implementations, but to be accorded the widest scope consistent with described principles and features. The described methods, processes, or logic flows can be performed by one or more programmable computers executing one or more computer programs to perform functions by operating on input data and generating output data. The methods, processes, or logic flows can also be performed by, and computers can also be implemented as, special purpose logic circuitry, for example, a CPU, an FPGA, or an ASIC.
Computers for the execution of a computer program can be based on general or special purpose microprocessors, both, or another type of CPU. Generally, a CPU will receive instructions and data from and write to a memory. The essential elements of a computer are a CPU, for performing or executing instructions, and one or more memory devices for storing instructions and data. Generally, a computer will also include, or be operatively coupled to, receive data from or transfer data to, or both, one or more mass storage devices for storing data, for example, magnetic, magneto-optical disks, or optical disks. However, a computer need not have such devices. Moreover, a computer can be embedded in another device, for example, a mobile telephone, a personal digital assistant (PDA), a mobile audio or video player, a game console, a global positioning system (GPS) receiver, or a portable memory storage device.
Non-transitory computer-readable media for storing computer program instructions and data can include all forms of permanent/non-permanent or volatile/non-volatile memory, media and memory devices, including by way of example semiconductor memory devices, for example, random access memory (RAM), read-only memory (ROM), phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), and flash memory devices; magnetic devices, for example, tape, cartridges, cassettes, internal/removable disks; magneto-optical disks; and optical memory devices, for example, digital versatile/video disc (DVD), compact disc (CD)-ROM, DVD+/−R, DVD-RAM, DVD-ROM, high-definition/density (HD)-DVD, and BLU-RAY/BLU-RAY DISC (BD), and other optical memory technologies. The memory can store various objects or data, including caches, classes, frameworks, applications, modules, backup data, jobs, web pages, web page templates, data structures, database tables, repositories storing dynamic information, or other appropriate information including any parameters, variables, algorithms, instructions, rules, constraints, or references. Additionally, the memory can include other appropriate data, such as logs, policies, security or access data, or reporting files. The processor and the memory can be supplemented by, or incorporated in, special purpose logic circuitry.
To provide for interaction with a user, implementations of the subject matter described in this specification can be implemented on a computer having a display device, for example, a cathode ray tube (CRT), liquid crystal display (LCD), light emitting diode (LED), or plasma monitor, for displaying information to the user and a keyboard and a pointing device, for example, a mouse, trackball, or trackpad by which the user can provide input to the computer. Input can also be provided to the computer using a touchscreen, such as a tablet computer surface with pressure sensitivity, a multi-touch screen using capacitive or electric sensing, or another type of touchscreen. Other types of devices can be used to interact with the user. For example, feedback provided to the user can be any form of sensory feedback (such as, visual, auditory, tactile, or a combination of feedback types). Input from the user can be received in any form, including acoustic, speech, or tactile input. In addition, a computer can interact with the user by sending documents to and receiving documents from a client-computing device that is used by the user (for example, by sending web pages to a web browser on a user's mobile computing device in response to requests received from the web browser).
The term “graphical user interface,” or “GUI,” can be used in the singular or the plural to describe one or more graphical user interfaces and each of the displays of a particular graphical user interface. Therefore, a GUI can represent any graphical user interface, including but not limited to, a web browser, a touch screen, or a command line interface (CLI) that processes information and efficiently presents the information results to the user. In general, a GUI can include a number of user interface (UI) elements, some or all associated with a web browser, such as interactive fields, pull-down lists, and buttons. These and other UI elements can be related to or represent the functions of the web browser.
Implementations of the subject matter described in this specification can be implemented in a computing system that includes a back-end component, for example, as a data server, or that includes a middleware component, for example, an application server, or that includes a front-end component, for example, a client computer having a graphical user interface or a Web browser through which a user can interact with an implementation of the subject matter described in this specification, or any combination of one or more such back-end, middleware, or front-end components. The components of the system can be interconnected by any form or medium of wireline or wireless digital data communication (or a combination of data communication), for example, a communication network. Examples of communication networks include a local area network (LAN), a radio access network (RAN), a metropolitan area network (MAN), a wide area network (WAN), Worldwide Interoperability for Microwave Access (WIMAX), a wireless local area network (WLAN) using, for example, 802.11 a/b/g/n or 802.20 (or a combination of 802.11x and 802.20 or other protocols consistent with the present disclosure), all or a portion of the Internet, another communication network, or a combination of communication networks. The communication network can communicate with, for example, Internet Protocol (IP) packets, frame relay frames, Asynchronous Transfer Mode (ATM) cells, voice, video, data, or other information between network nodes.
The computing system can include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs executing on the respective computers and having a client-server relationship to each other.
While this specification contains many specific implementation details, these should not be construed as limitations on the scope of any inventive concept or on the scope of what can be claimed, but rather as descriptions of features that can be specific to particular implementations of particular inventive concepts. Certain features that are described in this specification in the context of separate implementations can also be implemented, in combination, in a single implementation. Conversely, various features that are described in the context of a single implementation can also be implemented in multiple implementations, separately, or in any sub-combination. Moreover, although previously described features can be described as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can, in some cases, be excised from the combination, and the claimed combination can be directed to a sub-combination or variation of a sub-combination.
Particular implementations of the subject matter have been described. Other implementations, alterations, and permutations of the described implementations are within the scope of the following claims as will be apparent to those skilled in the art. While operations are depicted in the drawings or claims in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed (some operations can be considered optional), to achieve desirable results. In certain circumstances, multitasking or parallel processing (or a combination of multitasking and parallel processing) can be advantageous and performed as deemed appropriate.
Moreover, the separation or integration of various system modules and components in the previously described implementations should not be understood as requiring such separation or integration in all implementations, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.
Accordingly, the previously described example implementations do not define or constrain the present disclosure. Other changes, substitutions, and alterations are also possible without departing from the spirit and scope of the present disclosure.
Furthermore, any claimed implementation is considered to be applicable to at least a computer-implemented method; a non-transitory, computer-readable medium storing computer-readable instructions to perform the computer-implemented method; and a computer system comprising a computer memory interoperably coupled with a hardware processor configured to perform the computer-implemented method or the instructions stored on the non-transitory, computer-readable medium.
Eberlein, Peter, Driesen, Volker
| Patent | Priority | Assignee | Title |
| 11537364, | Jun 27 2019 | SAP SE | Application assessment system to achieve interface design consistency across micro services |
| Patent | Priority | Assignee | Title |
| 5680573, | Jul 12 1994 | SYBASE, INC | Method of buffering data objects in a database |
| 5925100, | Mar 21 1996 | SYBASE, INC | Client/server system with methods for prefetching and managing semantic objects based on object-based prefetch primitive present in client's executing application |
| 5946647, | Feb 01 1996 | Apple Inc | System and method for performing an action on a structure in computer-generated data |
| 6055569, | Jan 27 1998 | GO AHEAD SOFTWARE INC | Accelerating web access by predicting user action |
| 6728726, | Mar 05 1999 | Microsoft Technology Licensing, LLC | Prefetching and caching persistent objects |
| 6810429, | Feb 03 2000 | Mitsubishi Electric Research Laboratories, Inc | Enterprise integration system |
| 6996680, | Mar 27 2003 | Hitachi, LTD | Data prefetching method |
| 7284096, | Aug 05 2003 | SAP SE | Systems and methods for data caching |
| 7523142, | Dec 17 2001 | SAP SE | Systems, methods and articles of manufacture for upgrading a database with a shadow system |
| 7529895, | Aug 22 2003 | International Business Machines Corporation | Method for prefetching non-contiguous data structures |
| 7558822, | Jun 30 2004 | GOOGLE LLC | Accelerating user interfaces by predicting user actions |
| 7657575, | Dec 30 2005 | SAP SE | Sequencing updates to business objects |
| 7720992, | Feb 02 2005 | SAP SE | Tentative update and confirm or compensate |
| 7734648, | Apr 11 2006 | SAP SE | Update manager for database system |
| 7739387, | Mar 08 2007 | SAP SE | System and method for message packaging |
| 7894602, | Mar 31 2006 | SAP SE | System and method for generating pseudo-random numbers |
| 7941609, | Feb 23 2007 | Microsoft Technology Licensing, LLC | HTTP acceleration by prediction and pre-fetching |
| 7962920, | Dec 22 2006 | SAP SE | Providing a business logic framework |
| 7971209, | May 18 2007 | SAP SE | Shortcut in reliable communication |
| 8126919, | Apr 11 2006 | SAP SE | Update manager for database system |
| 8200634, | Oct 08 2008 | SAP SE | Zero downtime maintenance using a mirror approach |
| 8225303, | Nov 30 2007 | SAP SE | System and method for providing software upgrades |
| 8250135, | Jul 09 2010 | SAP SE | Brokered cloud computing architecture |
| 8275829, | Mar 12 2007 | Citrix Systems, Inc. | Systems and methods of prefetching objects for caching using QoS |
| 8291038, | Jun 29 2009 | SAP SE | Remote automation of manual tasks |
| 8301610, | Jul 21 2010 | SAP SE | Optimizing search for insert-only databases and write-once data storage |
| 8302160, | Oct 17 2006 | SAP SE | Propagation of authentication data in an intermediary service component |
| 8316422, | Oct 17 2006 | SAP SE | Propagation of principal authentication data in a mediated communication scenario |
| 8321678, | Oct 17 2006 | SAP SE | System and method to send a message using multiple authentication mechanisms |
| 8326830, | Oct 06 2009 | BUSINESS OBJECTS SOFTWARE LIMITED | Pattern recognition in web search engine result pages |
| 8356010, | Aug 11 2010 | SAP SE | Online data migration |
| 8375130, | Dec 16 2010 | SAP SE | Shared resource discovery, configuration, and consumption for networked solutions |
| 8380667, | Aug 11 2010 | SAP SE | Selectively upgrading clients in a multi-tenant computing system |
| 8392573, | Jul 30 2010 | SAP SE | Transport of customer flexibility changes in a multi-tenant environment |
| 8402086, | Jul 09 2010 | SAP SE | Brokered cloud computing architecture |
| 8407297, | Oct 22 2007 | SAP SE | Systems and methods to receive information from a groupware client |
| 8434060, | Aug 17 2010 | SAP SE | Component load procedure for setting up systems |
| 8467817, | Jun 16 2011 | SAP SE | Generic business notifications for mobile devices |
| 8473942, | Nov 28 2008 | SAP SE | Changable deployment conditions |
| 8479187, | Dec 02 2008 | SAP SE | Adaptive switch installer |
| 8510710, | Oct 06 2008 | SAP SE | System and method of using pooled thread-local character arrays |
| 8543994, | Dec 07 2007 | SAP SE | Developing java server components without restarting the application server |
| 8555249, | Dec 13 2010 | SAP SE | Lifecycle stable user interface adaptations |
| 8560876, | Jul 06 2010 | SAP SE | Clock acceleration of CPU core based on scanned result of task for parallel execution controlling key word |
| 8566784, | Sep 22 2011 | SAP SE | Business process change controller |
| 8572369, | Dec 11 2009 | SAP SE | Security for collaboration services |
| 8577960, | Jul 29 2010 | SAP SE | Providing status information for components in a distributed landscape |
| 8600916, | Apr 21 2006 | KYNDRYL, INC | Office system content prediction based on regular expression pattern analysis |
| 8604973, | Nov 30 2010 | SAP SE | Data access and management using GPS location data |
| 8612406, | May 22 2012 | SAP SE | Sharing business data across networked applications |
| 8645483, | Nov 15 2011 | SAP SE | Groupware-integrated business document management |
| 8706772, | Dec 30 2010 | SAP SE | Strict tenant isolation in multi-tenant enabled systems |
| 8751573, | Nov 23 2010 | SAP SE | Cloud-processing management with a landscape directory |
| 8762731, | Sep 14 2012 | SAP SE | Multi-system security integration |
| 8762929, | Dec 16 2010 | SAP SE | System and method for exclusion of inconsistent objects from lifecycle management processes |
| 8793230, | Oct 23 2012 | SAP SE | Single-database multiple-tenant software system upgrade |
| 8805986, | Oct 31 2011 | SAP SE | Application scope adjustment based on resource consumption |
| 8868582, | Aug 23 2010 | SAP SE | Repository infrastructure for on demand platforms |
| 8875122, | Dec 30 2010 | SAP SE | Tenant move upgrade |
| 8880486, | Jul 27 2010 | SAP SE | Distributed database system utilizing an extended two-phase-commit process |
| 8924384, | Aug 04 2010 | SAP SE | Upgrading column-based databases |
| 8924565, | Jul 30 2010 | SAP SE | Transport of customer flexibility changes in a multi-tenant environment |
| 8972934, | Dec 20 2010 | SAP SE | Support for temporally asynchronous interface extensions |
| 8996466, | Dec 01 2008 | SAP SE | Extend crud to support lifecyle management and business continuity |
| 9003356, | Sep 22 2011 | SAP SE | Business process change controller |
| 9009105, | Dec 30 2010 | SAP SE | Application exits for consistent tenant lifecycle management procedures |
| 9026502, | Jun 25 2013 | SAP SE | Feedback optimized checks for database migration |
| 9026525, | Dec 27 2010 | SAP SE | Generic node including stored script |
| 9026857, | Oct 19 2012 | SAP SE | Method and system for postponed error code checks |
| 9031910, | Jun 24 2013 | SAP SE | System and method for maintaining a cluster setup |
| 9032406, | Jul 01 2010 | SAP SE | Cooperative batch scheduling in multitenancy system based on estimated execution time and generating a load distribution chart |
| 9069832, | Dec 21 2012 | SAP SE | Approach for modularized sychronization and memory management |
| 9069984, | Dec 21 2011 | SAP SE | On-demand authorization management |
| 9077717, | Nov 30 2012 | SAP SE | Propagation and adoption of extensions across applications in networked solutions |
| 9122669, | Aug 29 2008 | SAP SE | Flat schema integrated document oriented templates |
| 9137130, | Sep 22 2011 | SAP SE | Dynamic network load forecasting |
| 9182979, | Apr 29 2013 | SAP SE | Social coding extensions |
| 9183540, | Jul 03 2012 | SAP SE | Mobile device analytics engine |
| 9189226, | Jun 25 2013 | SAP SE | Software logistics protocols |
| 9223985, | Oct 09 2013 | SAP SE | Risk assessment of changing computer system within a landscape |
| 9229707, | Dec 18 2008 | SAP SE | Zero downtime mechanism for software upgrade of a distributed computer system |
| 9256840, | Dec 01 2011 | SAP SE | Establishing business networks using a shared platform |
| 9262763, | Sep 29 2006 | SAP SE | Providing attachment-based data input and output |
| 9274757, | Dec 19 2013 | SAP SE | Customer tailored release master plan generation for hybrid networked solutions |
| 9275120, | May 30 2012 | SAP SE | Easy query |
| 9436724, | Oct 21 2013 | SAP SE | Migrating data in tables in a database |
| 9724757, | Sep 06 2013 | HARBISONWALKER INTERNATIONAL, INC | Refractory component for lining a metallurgical vessel |
| 20040117398, | |||
| 20060069715, | |||
| 20060098253, | |||
| 20080120129, | |||
| 20090210866, | |||
| 20090288079, | |||
| 20090300597, | |||
| 20100023925, | |||
| 20100153341, | |||
| 20110252415, | |||
| 20120089664, | |||
| 20120233605, | |||
| 20120284080, | |||
| 20130007259, | |||
| 20130167079, | |||
| 20130325672, | |||
| 20130332424, | |||
| 20140047319, | |||
| 20140101099, | |||
| 20140108440, | |||
| 20140164963, | |||
| 20140258999, | |||
| 20140325069, | |||
| 20140325498, | |||
| 20140359594, | |||
| 20140379677, | |||
| 20150006608, | |||
| 20150100546, | |||
| 20150106140, | |||
| 20150178332, | |||
| 20150193224, | |||
| 20160085542, | |||
| 20160098267, | |||
| 20160098438, | |||
| 20160098443, | |||
| 20160162275, | |||
| 20160300156, | |||
| 20160358101, | |||
| 20170025441, | |||
| 20170116296, | |||
| 20170123787, | |||
| 20170161291, | |||
| 20170185392, | |||
| 20170344362, | |||
| 20180232382, | |||
| 20190243865, | |||
| 20190354621, |
| Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
| Dec 04 2018 | SAP SE | (assignment on the face of the patent) | / | |||
| Dec 04 2018 | EBERLEIN, PETER | SAP SE | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 047667 | /0530 | |
| Dec 04 2018 | DRIESEN, VOLKER | SAP SE | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 047667 | /0530 |
| Date | Maintenance Fee Events |
| Dec 04 2018 | BIG: Entity status set to Undiscounted (note the period is included in the code). |
| May 22 2024 | M1551: Payment of Maintenance Fee, 4th Year, Large Entity. |
| Date | Maintenance Schedule |
| Dec 01 2023 | 4 years fee payment window open |
| Jun 01 2024 | 6 months grace period start (w surcharge) |
| Dec 01 2024 | patent expiry (for year 4) |
| Dec 01 2026 | 2 years to revive unintentionally abandoned end. (for year 4) |
| Dec 01 2027 | 8 years fee payment window open |
| Jun 01 2028 | 6 months grace period start (w surcharge) |
| Dec 01 2028 | patent expiry (for year 8) |
| Dec 01 2030 | 2 years to revive unintentionally abandoned end. (for year 8) |
| Dec 01 2031 | 12 years fee payment window open |
| Jun 01 2032 | 6 months grace period start (w surcharge) |
| Dec 01 2032 | patent expiry (for year 12) |
| Dec 01 2034 | 2 years to revive unintentionally abandoned end. (for year 12) |