Joint training of machine learning models

Abstract

The invention provides federated models based on locally trained machine learning models. In embodiments, a method includes monitoring, by a computing device, changes to cache data of an entity in a group of networked entities, where the cache data includes model output data from a worker model and a master feature model of the entity, and where the worker model and the master model comprise machine learning models; iteratively updating, by the computing device, parameter weights of the worker model and the master feature model based on the monitoring, thereby generating an updated worker model and an updated master feature model; and providing, by the computing device, the updated worker model and the updated master feature model to a remote federation server for use in a federated model that merges the updated worker model and the updated master feature model of the entity with other updated master feature models and other updated worker models of other entities in the group of networked entities.

Description

Background Technology

[0001] The present invention relates generally to machine learning, and more specifically to the joint training of machine learning modules.

[0002] Typically, machine learning involves computers using algorithms and statistical models to analyze and derive inferences from patterns in data, learning and adapting without following explicit instructions. Machine learning algorithms build models based on sample data (e.g., training data) to make predictions or decisions without being explicitly programmed to do so. Machine learning models can learn and adapt over time using incoming data from a specific domain (e.g., a topic area). Data privacy concerns can limit the amount of data available to a computer system and may therefore affect the quality or quantity of data that can be used to train and / or update machine learning models.

[0003] Federation architecture (FA) is a pattern in enterprise architecture that allows interoperability and information sharing between lines of business (LOBs), IT systems, and applications within a semi-autonomous, decentralized organization. Federation learning (collaborative learning) is a machine learning technique that trains algorithms on multiple decentralized edge devices or servers while maintaining local data samples without exchanging those samples. This differs from traditional centralized machine learning techniques, where all local datasets are uploaded to a single server. Generally, federated learning enables multiple participants to build a shared machine learning model without sharing data. In one federated approach, parties jointly train a global machine learning model by exchanging summaries of their individual data with the help of a centralized aggregator. Although only summaries of each party's data are shared, these summaries can still reveal important private or sensitive information. Therefore, there is a need to address data privacy issues while enabling systems and methods to leverage the private data of multiple participants to build and train machine learning models. Summary of the Invention

[0004] In a first aspect of the invention, a computer-implemented method is provided, comprising monitoring changes in cached data of entities in a networked group of entities by a computing device. The cached data includes model output data from worker models and principal feature models of the entities. The worker models and principal feature models include machine learning models. The method further comprises iteratively updating the parameter weights of the worker models and principal feature models by the computing device based on the monitoring, thereby generating updated worker models and updated principal feature models. The method further comprises providing the updated worker models and updated principal feature models to a remote federation server by the computing device for use in a federated model that merges the updated worker models and updated principal feature models of the entities with other updated principal feature models and other updated worker models of other entities in the networked group of entities. Advantageously, such a method enables the generation of a federated model incorporating updated machine learning models from multiple entities in a networked group of entities without generating intermediate models that require updates at the local entity level.

[0005] In implementation, the model output data from the master feature model and the worker model are generated based on private data input from the entities. Therefore, embodiments of the present invention enable the joint model to utilize the master feature model and worker model generated based on the private data input of the respective entities, without requiring the joint model to access the private data.

[0006] In one embodiment, the method further includes determining the accuracy of the worker model and the principal feature model of an entity using a computing device. In another embodiment, iteratively updating the parameter weights of the worker model and the principal feature model of the entity is also based on the accuracy of the entity's principal feature model and worker model. Thus, embodiments of the present invention provide a joint server with worker and principal feature models updated based on accuracy, thereby improving the accuracy of the joint model utilizing the updated worker and principal feature models.

[0007] In another aspect of the invention, there is a computer program product comprising one or more computer-readable storage media having program instructions commonly stored on the one or more computer-readable storage media. The program instructions are executable by a computing device to monitor changes in cached data of entities in a networked group of entities. The cached data includes output data from worker models and master feature models of the entities. The worker models and master feature models include machine learning models. The program instructions are further executable to iteratively update the parameter weights of the worker models and master feature models based on the monitoring, thereby producing updated worker models and updated master feature models. Furthermore, the program instructions are executable to provide the updated master feature models and updated worker models to a remote federation server for use in a federated model that merges the updated master feature models and updated worker models of the entities with other updated master feature models and other updated worker models of other entities in the networked group of entities. Advantageously, such a computer program product enables the generation of federated models that incorporate updated machine learning models from multiple entities in a networked group of entities.

[0008] In implementation, model output data from the worker model and the main feature model are generated based on the private data input of the entities. Thus, embodiments of the present invention enable the joint model to utilize the main feature model and worker model generated based on the private data input of the respective entities.

[0009] In another aspect of the invention, there is a system comprising a processor, a computer-readable storage device, one or more computer-readable storage media, and program instructions commonly stored on the one or more computer-readable storage media. The program instructions are executable by a federation server to receive queries from participating members of a networked entity group. The program instructions are further executable to generate a federated model based on a master feature model and a worker model of a corresponding entity in the networked entity group. Furthermore, the program instructions are executable to generate a response to the query based on the output of the federated model. Further, the program instructions are executable to send a response to the query to the participating member. Each master feature model includes all features of the corresponding entity in the networked entity group. Each worker model includes a subset of all features of the corresponding entity in the networked entity group. Moreover, the master feature model and worker model are iteratively updated by the corresponding entity based on private data inaccessible to the federation server. Advantageously, such a system enables the federation server to respond to queries based on models of multiple participating entities without requiring the federation server to access the entities' private data.

[0010] In implementation, the system's program instructions can be further executed by a computing device to generate a vector graph representing relationships between multiple remote entities based on common information. In an embodiment, the program instructions can be further executed to identify networked groups of entities from among the multiple remote entities based on the vector graph. Thus, embodiments of the present invention construct a network of related entities whose principal characteristics and worker models can be utilized in a joint model available to the participating members of the network. Attached Figure Description

[0011] With reference to the accompanying drawings, various aspects of the invention are described in the following detailed description through non-limiting examples of exemplary embodiments.

[0012] Figure 1 A cloud computing node according to an embodiment of the present invention is depicted.

[0013] Figure 2 A cloud computing environment according to an embodiment of the present invention is described.

[0014] Figure 3 An abstract model layer according to one embodiment of the present invention is described.

[0015] Figure 4 This is a diagram illustrating an exemplary environment in which data flow between entities is restricted by regulatory rules.

[0016] Figure 5 A block diagram illustrating an exemplary environment according to various aspects of the present invention is shown.

[0017] Figure 6 A flowchart illustrating an exemplary method according to various aspects of the present invention is shown.

[0018] Figure 7 A diagram illustrating the identification of entity groupings according to various aspects of the present invention is shown.

[0019] Figure 8 An aggregation of worker models and key feature models by a single entity is shown according to an aspect of the invention.

[0020] Figure 9 A subset group data cache according to various aspects of the present invention is shown.

[0021] Figure 10 A diagram illustrating the generation of the joint model according to various aspects of the present invention is shown.

[0022] Figure 11 The use of a joint worker model according to various aspects of the present invention is illustrated.

[0023] Figure 12The workflow of a joint system of machine learning models according to various aspects of the present invention is illustrated. Detailed Implementation

[0024] The present invention relates generally to machine learning, and more specifically to the joint training of machine learning modules. According to various aspects of the invention, a system is provided to build a principal feature-level model (hereinafter referred to as the principal feature model) and a worker feature-level model (hereinafter referred to as the worker model) together with a joint model-level dynamic virtual learning network of individual entities for accurate prediction of sensitive data.

[0025] The use and development of computer systems that leverage machine learning models to learn and adapt are on the rise without following explicit instructions. Concerns about the use of data over time to update or improve machine learning models include data availability, as well as data privacy or sensitivity issues. Data privacy can be governed by individual or entity preferences and government regulations. For example, the General Data Protection Regulation (GDPR) is EU law addressing data privacy and security. Data privacy issues can limit the amount of data available to computer systems and may therefore affect the quality or quantity of data that can be used to train and / or update machine learning models.

[0026] Embodiments of the present invention provide a technical solution to address the technical problem of building and updating machine learning models when data access is restricted by the availability of private or sensitive data. In the implementation, a computer server establishes a dynamic virtual network of entities by calculating the public (non-private) characteristics of each entity, thereby grouping individual entities into multiple virtual temporary organizations or groups. Public characteristics may include, but are not limited to, entity size, entity owner characteristics, entity statistics, and / or any other type of information that the entity is allowed to share. In the implementation, the computer server utilizes natural language processing (such as the word2vec algorithm) to convert entity information into mathematical vectors. This algorithm is a natural language processing algorithm that uses neural network models to learn word associations from large text corpora. In the embodiments, the computer server calculates the vector distance of each entity and then groups the closest entities into temporary organizations or groups containing entities with a high degree of similarity (highly similar entities). Data from entities in specific temporary organizations can be used to advance machine learning.

[0027] In an embodiment, for each virtual network or subset, the computer server builds a master feature model and multiple worker models, then aggregates the results with a dynamic relationship to feature weights. In the implementation, the master feature model is used to rate all private features of an entity and can store the overall data. However, the master feature model may be inconvenient for continuous learning because it utilizes a relatively large amount of data when refreshed or updated. Each worker model contains partial private features and is relatively easy to refresh / update because it uses only minimal data for continuous learning as a complement to the master feature model. In an embodiment, the computer server (e.g., an entity server) aggregates the master feature model and worker models to achieve multidimensional private feature learning. In the implementation, the aggregated feature model weights are assigned initial values ​​by the entity, but these values ​​will change dynamically as the continuous data stream is cached.

[0028] In various aspects of this invention, the aggregated models (e.g., principal feature models and worker models) are adjusted by the entities because the private features of the learning objects can change at any time. For example, private features (private data) that can change over time include, but are not limited to, environmental upgrades, feature scaling, and data distribution. In embodiments, retraining includes either a new model with the same set of features or a new principal feature model or worker model with a completely new set of features. In embodiments, a computer server (e.g., an entity server) classifies the newly retrained models using model metrics and then selects the top N models as the new set of principal feature models and worker models. In implementation, the computer server also uses model metric analysis formulas to adjust model weights.

[0029] In this embodiment, the federated server combines the principal feature models and worker models of entities into a joint virtual network model (the federated model) configured to predict the final result of a user query. In the implementation, the federated server identifies all principal feature models and worker models of relevant entities in the dynamic virtual network of entities. In this embodiment, federated learning utilizes parallel computation of weight formulas to combine all entity models. The parallel computation of weight formulas can be asynchronous stochastic gradient descent (SGD) or parametric averaging, depending on performance cost and computational metrics.

[0030] Based on the above, it can be understood that the implementation of the present invention utilizes joint learning to generate a master machine learning model (e.g., a joint model) based on models from individual entities within the network. This master machine learning model can be used to answer queries against network members without directly obtaining private data from individual entities within the network. Therefore, embodiments of the present invention address the technical problem of establishing and updating machine learning models when data access is restricted by privacy or sensitivity issues, utilizing techniques including those for generating master machine learning models.

[0031] It should be understood that, to the extent that personal information (e.g., private data of entity members) provided or obtained by individuals is collected, stored, or used in the implementation of this invention, such information should be used in accordance with all applicable laws concerning the protection of personal information. Furthermore, the collection, storage, and use of such information may be subject to the individual's consent to such activities, for example, through an "option-on" or "option-off" process that may be appropriate to the circumstances and type of information. The storage and use of personal information may reflect the type of information in an appropriately secure manner, for example, through different encryption and anonymization methods.

[0032] This invention can be a system, method, and / or computer program product at any possible level of technical detail integration. The computer program product may include a computer-readable storage medium (or media) having computer-readable program instructions thereon for causing a processor to execute aspects of the invention.

[0033] A computer-readable storage medium can be a tangible device capable of retaining and storing instructions for use by an instruction execution device. A computer-readable storage medium can be, for example, but not limited to, electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of computer-readable storage media includes: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital universal disk (DVD), memory sticks, floppy disks, mechanical encoding devices such as punch cards or protrusions in slots having instructions recorded thereon, and any suitable combination of the foregoing. As used herein, a computer-readable storage medium or medium should not be construed as a transient signal itself, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses through fiber optic cables), or electrical signals transmitted through wires.

[0034] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a corresponding computing / processing device or to an external computer or external storage device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network). The network may include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards them to a computer-readable storage medium within the corresponding computing / processing device.

[0035] Computer-readable program instructions used to perform the operations of this invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, integrated circuit configuration data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​(such as Smalltalk, C++, etc.) and procedural programming languages ​​(such as the "C" programming language or similar programming languages). The computer-readable program instructions may be executed entirely on a user's computer, partially on a user's computer, as a standalone software package, partially on a user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network (including a local area network (LAN) or a wide area network (WAN)) or may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs) may execute computer-readable program instructions by utilizing state information from the computer-readable program instructions to personalize the electronic circuitry in order to perform aspects of this invention.

[0036] This document describes various aspects of the invention with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0037] These computer-readable program instructions may be provided to a computer processor or other programmable data processing apparatus to produce a machine, such that these instructions, which execute via the computer processor or other programmable data processing apparatus, create means for implementing the functions / actions specified in one or more blocks of a flowchart and / or block diagram. These computer-readable program instructions may also be stored in a computer-readable storage medium that causes a computer, programmable data processing apparatus, and / or other device to operate in a particular manner, thereby comprising an article of manufacture containing instructions that implement aspects of the functions / actions specified in one or more blocks of a flowchart and / or block diagram.

[0038] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other apparatus to cause a series of operational steps to be performed on the computer, other programmable apparatus, or other apparatus to produce a computer-implemented process, such that the instructions that execute on the computer, other programmable apparatus, or other apparatus perform the functions / actions specified in one or more boxes of a flowchart and / or block diagram.

[0039] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. Each block in a flowchart or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions marked in the blocks may occur in a different order than those marked in the figures. For example, two blocks shown consecutively may actually be completed as a single step, executed simultaneously, substantially simultaneously, or with partial or complete temporal overlap, or the blocks may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented using a dedicated hardware-based system that performs the specified function or action or executes a combination of dedicated hardware and computer instructions.

[0040] It should be understood in advance that although this disclosure includes a detailed description of cloud computing, the implementation of the teachings described herein is not limited to a cloud computing environment. Rather, embodiments of the invention can be implemented in conjunction with any other type of computing environment now known or developed hereafter.

[0041] Cloud computing is a service delivery model designed to enable convenient, on-demand network access to a shared pool of configurable computing resources (e.g., a shared pool of configurable computing resources). These resources (networks, network bandwidth, servers, processing power, storage, applications, virtual machines, and services) can be rapidly provisioned and released with minimal management effort or interaction with the service provider. This cloud model may include at least five features, at least three service models, and at least four deployment models.

[0042] The characteristics are as follows:

[0043] On-demand self-service: Cloud consumers can automatically and unilaterally configure computing power, such as server time and network storage, as needed, without human interaction with the service provider.

[0044] Extensive network access: Capabilities are available through networks and accessed via standard mechanisms that facilitate the use of heterogeneous thin client or thick client platforms (e.g., mobile phones, laptops, and PDAs).

[0045] Resource pooling: A provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, where different physical and virtual resources are dynamically allocated and reallocated as needed. There is a sense of location independence because consumers typically do not have control or knowledge of the exact location of the resources provided, but may be able to specify the location at a higher level of abstraction (e.g., country, state, or data center).

[0046] Rapid flexibility: The ability to provide capacity quickly and flexibly, automatically scaling down and up rapidly in some situations to scale up rapidly. For consumers, the available supply capacity often appears unlimited and can be purchased in any quantity at any time.

[0047] Measurement services: Cloud systems automatically control and optimize resource usage by leveraging metering capabilities at a level of abstraction appropriate to the service type (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, and reported, providing transparency to both service providers and consumers.

[0048] The service model is as follows:

[0049] Software as a Service (SaaS): This provides consumers with the ability to use a provider's applications running on cloud infrastructure. These applications can be accessed from different client devices via a thin client interface such as a web browser (e.g., web-based email). Consumers do not manage or control the underlying cloud infrastructure, including the network, servers, operating system, storage, or even individual application capabilities, with possible exceptions such as limited user-specific application configuration settings.

[0050] Platform as a Service (PaaS): This provides consumers with the ability to deploy applications created by the consumer or acquired using programming languages ​​and tools supported by the provider onto cloud infrastructure. Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but they have control over the deployed applications and the configuration of possible application hosting environments.

[0051] Infrastructure as a Service (IaaS): This provides consumers with the capability to offer processing, storage, networking, and other basic computing resources, where consumers can deploy and run arbitrary software, which may include operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but rather have control over the operating system, storage, deployed applications, and potentially limited control over selected networking components (e.g., host firewalls).

[0052] The deployment model is as follows:

[0053] Private cloud: A cloud infrastructure that operates solely for an organization. It can be managed by the organization or a third party and can exist on-site or off-site.

[0054] Community cloud: A cloud infrastructure shared by several organizations and supporting a specific community with shared concerns (e.g., tasks, security requirements, policies, and compliance considerations). It can be managed by an organization or a third party and can exist on-site or off-site.

[0055] Public cloud: Cloud infrastructure that is made available to the public or large industry groups and is owned by an organization that sells cloud services.

[0056] Hybrid cloud: A cloud infrastructure is a combination of two or more clouds (private, community, or public clouds) that remain a single entity but are bound together by standardized or proprietary technologies that enable data and applications to be ported (e.g., cloud bursting for load balancing between clouds).

[0057] Cloud computing environments are service-oriented, focusing on statefulness, loose coupling, modularity, and semantic interoperability. At the heart of cloud computing is the infrastructure that includes a network of interconnected nodes.

[0058] See now Figure 1 The diagram illustrates an instance of a cloud computing node. Cloud computing node 10 is merely one example of a suitable cloud computing node and is not intended to impose any limitation on the use or scope of functionality of the embodiments of the invention described herein. In any case, cloud computing node 10 can be implemented and / or perform any of the functions set forth above.

[0059] Within cloud computing node 10, there exists a computer system / server 12 that can operate alongside many other general-purpose or special-purpose computing system environments or configurations. Examples of known computing systems, environments, and / or configurations that may be suitable for computer system / server 12 include, but are not limited to, personal computer systems, server computer systems, thin clients, thick clients, handheld or laptop devices, multiprocessor systems, microprocessor-based systems, set-top boxes, programmable consumer electronics, network PCs, minicomputer systems, mainframe computer systems, and distributed cloud computing environments that include any of the aforementioned systems or devices.

[0060] The computer system / server 12 can be described in the general context of computer system executable instructions (such as program modules) executed by the computer system. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc., that perform specific tasks or implement specific abstract data types. The computer system / server 12 can be implemented in a distributed cloud computing environment, where tasks are performed by remote processing devices linked via a communication network. In a distributed cloud computing environment, program modules can reside in local and remote computer system storage media, including memory storage devices.

[0061] like Figure 1 As shown, the computer system / server 12 in cloud computing node 10 is illustrated in the form of a general-purpose computing device. The components of the computer system / server 12 may include, but are not limited to, one or more processors or processing units 16, system memory 28, and a bus 18 that couples the various system components, including the system memory 28, to the processor 16.

[0062] Bus 18 represents any one or more of several types of bus architectures, including memory buses or memory controllers, peripheral buses, accelerated graphics ports, and processor or local buses using any of the various bus architectures. By way of example and not limitation, such architectures include Industry Standard Architecture (ISA) buses, Micro Channel Architecture (MCA) buses, Enhanced ISA (EISA) buses, Video Electronics Standards Association (VESA) local buses, and Peripheral Component Interconnect (PCI) buses.

[0063] Computer system / server 12 typically includes a variety of computer system readable media. Such media can be any available media that can be accessed by computer system / server 12, and includes volatile and non-volatile media, removable and non-removable media.

[0064] System memory 28 may include computer system readable media in the form of volatile memory, such as random access memory (RAM) 30 and / or cache memory 32. Computer system / server 12 may further include other removable / non-removable, volatile / non-volatile computer system storage media. By way of example only, memory system 34 may be provided for reading from and writing to non-removable, non-volatile magnetic media (not shown, and generally referred to as "hard disk drives"). Although not shown, disk drives for reading from or writing to removable non-volatile disks (e.g., "floppy disks") and optical disk drives for reading from or writing to removable non-volatile optical disks (e.g., CD-ROMs, DVD-ROMs, or other optical media) may be provided. In such cases, each may be connected to bus 18 via one or more data media interfaces. As will be further described and illustrated below, memory 28 may include at least one program product having a set (e.g., at least one) of program modules configured to perform embodiments of the invention.

[0065] A program / utility 40 having a set (at least one) of program modules 42, along with an operating system, one or more applications, other program modules, and program data, may be stored in memory 28 by way of example, not limitation. Each or some combination of the operating system, one or more applications, other program modules, and program data may include an implementation of a network environment. Program modules 42 typically perform functions and / or methods as described herein in embodiments of the invention.

[0066] Computer system / server 12 can also communicate with one or more external devices 14 (such as a keyboard, pointing device, display 24, etc.); and / or any device that enables computer system / server 12 to communicate with one or more other computing devices (e.g., network interface card, modem, etc.). This communication can be performed via input / output (I / O) interface 22. Furthermore, computer system / server 12 can communicate with one or more networks, such as a local area network (LAN), a general wide area network (WAN), and / or a public network (e.g., the Internet), via network adapter 20. As shown, network adapter 20 communicates with other components of computer system / server 12 via bus 18. It should be understood that, although not shown, other hardware and / or software components can be used in conjunction with computer system / server 12. Examples include, but are not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archiving storage systems.

[0067] See now Figure 2The diagram illustrates an illustrative cloud computing environment 50. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10 to which local computing devices used by cloud consumers can communicate. These local computing devices include, for example, personal digital assistants (PDAs) or cellular phones 54A, desktop computers 54B, laptop computers 54C, and / or automotive computer systems 54N. The nodes 10 can communicate with each other. They can be physically or virtually grouped (not shown) in one or more networks, such as private clouds, community clouds, public clouds, or hybrid clouds, or combinations thereof, as described above. This allows the cloud computing environment 50 to provide infrastructure, platforms, and / or software as services that cloud consumers do not need to maintain on their local computing devices. It should be understood that... Figure 2 The types of computing devices 54A-N shown are intended to be illustrative only, and computing node 10 and cloud computing environment 50 can communicate with any type of computerized device via any type of network and / or network-addressable connectivity (e.g., using a web browser).

[0068] See now Figure 3 This demonstrates a cloud computing environment of 50 ( Figure 2 This provides a set of functional abstractions. It should be understood beforehand. Figure 3 The components, layers, and functions shown are intended to be illustrative only, and embodiments of the invention are not limited thereto. As described, the following layers and corresponding functions are provided:

[0069] The hardware and software layer 60 includes hardware and software components. Examples of hardware components include: a mainframe 61; a RISC (Reduced Instruction Set Computer) based server 62; a server 63; a blade server 64; a storage device 65; and network and networking components 66. In some embodiments, software components include network application server software 67 and database software 68.

[0070] The virtualization layer 70 provides an abstraction layer from which the following examples of virtual entities can be provided: virtual server 71; virtual storage 72; virtual network 73, including virtual private network; virtual application and operating system 74; and virtual client 75.

[0071] In one example, management layer 80 may provide the following functionalities: Resource Provisioning 81 provides dynamic procurement of computing resources and other resources used to perform tasks within the cloud computing environment. Metering and Pricing 82 provides cost tracking as resources are utilized within the cloud computing environment and bills or invoices for the consumption of these resources. In one example, these resources may include application software licenses. Security provides authentication for cloud consumers and tasks, as well as protection for data and other resources. User Portal 83 provides access to the cloud computing environment for consumers and system administrators. Service Level Management 84 provides cloud resource allocation and management to ensure that required service levels are met. Service Level Agreement (SLA) Planning and Fulfillment 85 provides pre-scheduling and procurement of cloud resources based on anticipated future needs according to the SLA.

[0072] Workload layer 90 provides examples of functionalities that can be leveraged in a cloud computing environment. Examples of workloads and functionalities that can be provided from this layer include: mapping and navigation 91; software development and lifecycle management 92; virtual classroom education delivery 93; data analytics and processing 94; transaction processing 95; and federated model training 96.

[0073] The implementation of the present invention may include Figure 1 The computer system / server 12, wherein one or more of the program modules 42 are configured to execute (or cause the computer system / server 12 to execute). Figure 3 The joint model training 96 has one or more functions. For example, one or more program modules in program module 42 can be configured to: collect public information from participating entities to identify related entity groups; build worker and master feature models for each entity in the related entity groups; monitor the entity's data cache to indicate changes to privacy information; update or train worker and master feature models at the entities; generate a joint model based on the updated worker and master feature models; and generate a response to user queries using the joint model.

[0074] Figure 4 This diagram illustrates an exemplary environment 400 where data flow between entities is restricted by regulatory rules. As shown, in step 1, entity A (first data controller) creates data 1. In a typical unrestricted data exchange, in step 2, entity A transmits data 1 to entity B (second data controller); in step 3, entity B creates data 2 and stores data 1 from entity A; and in step 4, entity A receives data 2 from entity B. Figure 4In scenario 401, data flow from entity A to entity B is restricted by administrative rules (e.g., GDPR rules). Similarly, in scenario 402, data flow from entity B to entity A is restricted by administrative rules. In this case, model training at entities A and B is impossible due to a lack of sufficient training data. Embodiments of the present invention provide a technical solution to this problem by generating a joint model for use by multiple entities.

[0075] Figure 5 A block diagram of an exemplary environment 500 according to various aspects of the present invention is shown. In an embodiment, environment 500 includes a network 501 connecting a federated server 502 and a plurality of single-entity servers 504, the plurality of single-entity servers 504 being represented by a first entity server 504A, a second entity server 504B, and a third entity server 504C. Each single-entity server 504 may include one or more computing systems (e.g., Figure 1 The computer system 12). In an embodiment, each of the single-entity servers 504 includes Figure 2 One or more compute nodes 10 in a cloud computing environment 50. In an implementation, one or more single-entity servers 504 include dedicated computing devices configured to generate and update machine learning models using machine learning techniques.

[0076] Network 501 can be any suitable communication network or combination of networks, such as a local area network (LAN), a general wide area network (WAN), and / or a public network (e.g., the Internet). In the implementation, federated server 502 provides services to participating users in the cloud network.

[0077] In this embodiment, the term "single entity" as used herein refers to an entity governed by a different set of rules and / or regulations, such as a corporation, subsidiary, non-profit organization, or government agency. In the implementation, each entity is a single entity governed by data-sharing rules that prevent the sharing of certain kinds of data with other entities (e.g., policies, rules, and / or laws restrict data flow between entities).

[0078] In implementation, each entity server 504 communicates directly or indirectly with one or more entity devices 505 represented by a first entity device 505A, a second entity device 505B, and a third entity device 505C. Each of the entity devices 505 may include one or more computing systems (e.g., Figure 1 The computer system 12 can be, for example, a desktop computer, laptop computer, tablet computer, smartphone, or other personal computing device. In embodiments, the physical device 505 includes Figure 2 One or more computing nodes 10 in a cloud computing environment 50.

[0079] Continue to refer to Figure 5 Each entity server 504 may include one or more program modules (e.g., Figure 1 The program module 42), which is executed by entity server 504 and configured to perform one or more functions described herein. In an embodiment, each single entity server 504 includes a shared information module (e.g., program module 42), indicated at 510, 510', and 510", configured to acquire and / or transfer data between entity server 504's data cache (indicated at 511, 511', and 511") and other entity servers 504 and / or federated servers 502; and a machine learning (ML) module (e.g., program module 42), indicated at 512, 512', and 512", configured to train a master feature model and a worker model using data from one or more entity servers 504, and to generate model output data using the locally trained master feature model and worker model. In the implementation, entity server 504 is configured to acquire and / or transfer data from entity server 504's data cache (indicated at 511, 511', and 511") and / or federated servers 502. Figure 5 The data storage devices denoted by 513, 513” and 513”” collect data (e.g., data about features).

[0080] Still referencing Figure 5 Federation server 502 may include one or more program modules executed by federation server 502 and configured to perform one or more functions described herein (e.g., Figure 1 (Program module 42). In an implementation, the federated server 502 includes one or more of the following modules (e.g., program module 42): a data collection module 514 configured to collect public information from multiple entity servers 504 that can be stored in a database 515; a model building module 516 configured to generate a federated model from multiple master features and worker models; and a federated model module 517 configured to obtain user queries and generate and output answers to user queries (e.g., queries from entity servers 504 and / or entity devices 505). In an implementation, the federated model module 517 is configured to answer questions in one or more subject domains and make it available to members of a dynamic virtual network of entities identified by the federated server 502 according to an embodiment of the invention.

[0081] In embodiments, the individual modules described above can be integrated into a single module. Alternatively, the single module described above can be implemented as multiple modules. Furthermore, the number of devices and / or networks in environment 500 is not limited to... Figure 5 The quantities shown. In reality, environment 500 may include more than... Figure 5The additional devices and / or networks shown, fewer devices and / or networks, different devices and / or networks, or devices and / or networks arranged differently.

[0082] Figure 6 A flowchart illustrating an exemplary method according to various aspects of the present invention is shown. The steps of the method can be... Figure 5 Execute in the environment and refer to Figure 5 The components described herein are described.

[0083] Dynamic virtual network for identifying entities

[0084] At step 600, each participating single-entity server (e.g., first entity server 504A) and / or federated server 502 collects public information from multiple single-entity participants (e.g., via participating single-entity servers 504) and stores that information in a database (e.g., shared information module 510). As used herein, the term "public information" refers to information not subject to restrictive sharing policies, rules, or regulations. For example, public information as used herein could be information about the characteristics of a single-entity participant that is not private, sensitive, or otherwise restricted from dissemination to other entities. Conversely, as used herein, the term "private data" refers to information subject to restrictive sharing policies, rules, or regulations. For example, private data as used herein could include information about entities that are private, sensitive, or otherwise restricted from dissemination to other entities.

[0085] Continuing with step 600, data may be collected continuously or periodically by each entity server (e.g., first entity server 504A, second entity server 504B, third entity server 504C) and may be cached in data blocks specific to the respective individual entity participant. Figure 6In the example, the first entity server 504A collects public information from the second entity server 504B and the third entity server 504C, each server being associated with a participating entity. In this embodiment, the public information includes execution context data that provides context information about the tasks or functions performed by the respective entities. The public information may include, for example: entity size information (e.g., data about the size of an entity, or the entity's tasks and / or functions); entity owner characteristics; entity univariate statistics (e.g., statistics about a single variable or variable); and entity financial resources (e.g., debt, income, etc.). In this implementation, the public information includes any information that enables each entity and / or the federated server 502 to determine a similarity level between entities based on features of interest. As used herein, features of interest (hereinafter referred to as features) refer to information obtained or derived from the public information that can be incorporated into a machine learning model. In this implementation, the federated server 502 identifies features of multiple remote entities based on the public information obtained in step 600. In this embodiment, the entity server 504 and / or the federated server 502 obtain only public feature data based on predetermined rules (e.g., user-selected rules). In one embodiment, the shared information module (e.g., 510) of a single-entity server implements step 600. In an alternative implementation, the data collection module 514 of the federated server 502 is configured to implement step 600.

[0086] In an embodiment, in step 601, a single-entity server (e.g., a subsequent first entity server 504A) or a federated server 502 generates a vector graph for each single-entity participant, which represents the relationships between single-entity participants and other single-entity participants based on features identified in step 600 (e.g., public information collected in step 600). In various aspects of the invention, the first entity server 504A or the federated server 502 utilizes natural language processing (such as the word2vec algorithm) to generate the vector graph. In an embodiment, the first entity server 504A or the federated server 502 calculates the vector distance for each entity based on the vector graph, and then groups the closest entities into temporary organizations or subsets containing entities with a large number of similarities (e.g., related entities). In an embodiment, the first entity server 504A or the federated server 502 applies different weights to different features when generating the vector graph. In implementation, the first entity server 504A or the federated server 502 uses the following vector formula (1) to generate the vector graph.

[0087] Formula (1):

[0088] in: It is a vector representing the common characteristics or features of a single entity; It means Sub-vectors (features) of factors in the multidimensional space; N is the entity. The dimensions of the features; Meaning entity With entity The distance between them, and Meaning entity With entity The relationship between them. In one embodiment, the shared information module (e.g., 510) of each entity server 504 implements step 601. In an alternative embodiment, the data collection module 514 of the federated server 502 implements step 601.

[0089] At step 602, in an embodiment, the first entity server 504A or the federated server 502 identifies groups (subsets) of related entities. In implementation, the first entity server 504A or the federated server 502 identifies subset groups based on the vector mapping generated in step 601. In various aspects, a dynamic virtual network of entities comprising multiple subset groups is identified by the first entity server 504A or the federated server 502 based on the vector mapping of step 601. In implementation, the first entity server 504A or the federated server 502 calculates the vector distance between entities and groups entities with the closest distance into temporary organizations (subsets) containing highly similar entities. In an embodiment, entities are grouped based on stored rules (e.g., threshold vector distance). In an embodiment, a shared information module (e.g., 510) of the first entity server 504A implements step 602. In an alternative embodiment, a data collection module 514 of the federated server 502 implements step 602. (Discussed below) Figure 7 An illustrative example of step 602 is shown in the figure.

[0090] It should be understood that steps 600-602 can be repeated periodically, and the subset groups within the dynamic virtual network of entities can change over time (e.g., new groups can be added or removed) as the characteristics of one or more individual entities change. In an embodiment, the first entity server 504A or the federation server 502 issues a notification to the participating entities indicating the relevant entity groups (subset groups). The notification may be issued when a change is made to one or more of the subset groups, or when a subset group is added or removed.

[0091] Generate main feature model and worker model

[0092] In step 603, subset groups (e.g., Figure 7 The corresponding entity in 702A) (e.g., Figure 7Each participating single-entity server (e.g., the first entity server 504A) in the main feature model (A, C, and F) constructs multiple worker models (machine learning models) based on a subset of features in the main feature model. In the implementation, different worker models can be based on different enterprise transaction types, employee work locations, etc. In an embodiment, the first entity server 504A constructs S worker models using a subset of features from the main feature model, where S = the size of the subset of features. For example, when S = 3, the worker model includes features from the main feature model (e.g., ...). Figure 7 (FM1, FM2, and FM3). In the implementation, the worker model includes fixed key features (such as financial status, business revenue, etc.) and / or optional features (such as metadata, parameters, etc.). Different model building tools can be used to build the worker model, and the implementation herein is not intended to be limited by the methods used to build machine learning models. In an embodiment, the ML module (e.g., ML module 512) of each entity server (e.g., first entity server 504A) implements step 603.

[0093] At step 604, the subset group (e.g., Figure 7 The corresponding entity in 702A) (e.g., Figure 7 Each participating single-entity server (e.g., the first entity server 504A) of A, C, and F utilizes all features of the worker model (e.g., Figure 7 The main feature model (machine learning model) is constructed using F1, F2, and F3. Different model building tools can be used to construct the main feature model for all features of interest (e.g., the features for which information is collected at step 600), and the embodiments herein are not intended to be limited to the methods used to construct the machine learning model. In the embodiments, step 604 is implemented by the ML module (e.g., ML module 512) of each entity server (e.g., first entity server 504A).

[0094] In one example, the data storage (e.g., 513) of the first worker device (e.g., one of the physical devices 505A) includes data regarding the following database statistics used to build the first worker model: table cardinality, page number, and access frequency. In this example, the data storage of the second worker device includes data regarding the following database statistics used to build the second worker model: index level, I / O speed, and access frequency. Furthermore, in this example, the data storage of the third worker device includes data regarding the following database statistics used to build the third worker model: leaf page, page number, and system cache. In this example, there is some overlap in the characteristics of the first, second, and third worker models. Therefore, the master feature model will consider all the aforementioned characteristics of each worker model. Thus, each worker model considers a subset of the feature set or total features considered by the master feature model, such as in subset groups (e.g., ...). Figure 7 The exemplary main feature table of entities A, C and F of (702B) is shown.

[0095]

[0096] Table 1 is a sample feature table, showing the features of the main feature model.

[0097] At step 605, each participating single-entity server (e.g., first entity server 504A) for the corresponding entities (e.g., A, C, and F) in the subset group (e.g., 702A) assigns weights (aggregate weights) to the outputs of the main feature model and the worker model. In one example, the first entity server 504 assigns a main feature model output weight of 0.5 and a worker model output weight of 0.17 to the worker model n. The initial assignment of weights by the entity servers can be based on predetermined default weights, predetermined rules, or can be manually assigned.

[0098] In an embodiment, each entity in the subset trains its main feature and worker models locally based on local data (e.g., private data). Implementations of the invention are not intended to be limited to a particular method of model training. In the implementation, the output data of the main feature and worker models is cached by each entity in a corresponding data cache accessible by other participating entities (e.g., other entities in the same subset). For example, model output data from the first entity server 504A may be stored in data cache 511. In an embodiment, the ML module (e.g., ML module 512) of each entity server (e.g., the first entity server 504A) implements step 605.

[0099] Local training

[0100] At step 606, each participating single-entity server (e.g., first entity server 504A) identifies changes to these data caches based on monitoring of one or more data caches (e.g., 511, 511', 511"). In an embodiment, participating entities (e.g., Figure 7 The cached data of subset group 702A (A, C, and F) includes aggregated master features and worker model output data from the respective entity and / or from another participating entity. For example, data changes may include: information about characters in the input data; values ​​of key parameters; information about the selected enterprise; and observed responses. In one example, the first entity server 504A includes rules to identify the type or category of information being monitored for changes, such that in step 607, any change to the monitored information in the data cache (e.g., 511) triggers an evaluation of the accuracy of the cached data. In implementation, the cached data involves private data, but the private data is not publicly disclosed. In aspects of the invention, each participating single entity server 504 identifies changes to the cached data that indicate changes to private data (to the private data inputs of the master features and worker models) on the entity side (e.g., at the first entity server 504A). In implementation, the ML module (e.g., 512) of the participating single entity server monitors the incoming data according to step 606. Discussed below... Figure 8 The example shown illustrates how to use the entity’s main feature model and worker model to generate model output data.

[0101] In step 607, each participating single-entity server (e.g., first entity server 504A) calculates the accuracy of the model (MA2). See Equation (2) below. In an embodiment, each participating single-entity server 504 initiates a calculation of the model's accuracy when the cached data associated with the model exceeds a user-specified data threshold. Different methods may be used to calculate the model's accuracy, and implementations of the invention are not intended to be limited to the examples described herein. In the implementation, the ML module (e.g., 512) of each participating single-entity server 504 implements step 607.

[0102] In step 608, each participating single-entity server (e.g., first entity server 504A) updates or adjusts the weights of the worker and principal feature model as needed (originally applied in step 605) based on predetermined rules. In statistical modeling, regression analysis is a set of statistical procedures used to estimate the relationship between a dependent variable and one or more independent variables. Error metrics can be computed for regression prediction models. Metrics used for regression involve calculating an error score to summarize the model's predictive ability. Three error metrics commonly used to evaluate and report the performance of regression models include: mean squared error (MSE); root mean square error (RMSE); and mean absolute error (MAE). In the implementation, when each participating single-entity server 504 determines that the cached data in the data cache (e.g., 511) is greater than a user-specified data threshold, it initiates a model accuracy or model metric (MAE) assessment of the cached data. 2 The calculation of ) is performed, and the weights of the worker model are adjusted using the following formula (2).

[0103] Formula (2)

[0104]

[0105] In implementation, one of the following error metrics can be used as a model metric (MA). 2 ): Mean squared error (MSE), root mean square error (RMSE), or mean absolute error (MAE). In this example, WW in formula (2) i This represents the adjusted weights of the i worker models (because new data is entering the entity, the worker model weights in that entity will need to be adjusted), and WW j This represents the weights of other worker models (1 to j) excluding i. Similarly, the principal feature model of an entity utilizes the same strategy as the worker models. When Equation (2) indicates the principal feature model weight adjustment, the cached WW can be converted to the cached MW, which is the adjusted principal model weight, and WW(j) then indicates all worker models (from 1 to j, including i), since the principal feature model weight will be adjusted by all worker models. Thus, in an embodiment of the invention, each participating single entity server 504 adjusts the weights of the workers and principal feature models of the associated entity based on the accuracy of the calculated cached data. In the implementation, the ML module (e.g., 512) of each participating single entity server (e.g., 504A) implements step 608. Discussed below Figure 9 The text describes an illustrative example of generating new model data from relevant entities used for model training.

[0106] Joint model

[0107] In step 609, the federated server 502 receives queries from the participating members of the subset group. For example, Figure 7 Employees of entity A in subset group 702B can submit queries to federation server 502 that can be addressed by the federation machine learning model using a graphical user interface (GUI) provided by federation server 502. In implementation, federation server 502 identifies the principal features and worker models associated with participating members. Participating members of the dynamic virtual network of entity 700 can register with federation server 502, and federation server 502 can identify participating members based on login information provided by the participating members to access the machine learning services of federation server 502. For example, the member could belong to entity A in subset group 702B. In this instance, federation server 502 will generate output (joint prediction) in response to the query, using the principal features and worker models associated with subset group 702B. In an embodiment, federation model module 517 implements step 609.

[0108] In step 610, the federation server 502 bases its decisions on a subset of participating members (e.g., Figure 7 A federated model is built for each entity in subset group 702B (in the subset group 702B) using its principal feature model and worker model. In the implementation, federated server 502 identifies and obtains all principal feature and worker models in the subset group. For example, for a query from an employee of entity A, in subset group 702B, federated server 502 obtains and utilizes the principal feature models and worker models of entities A, C, and F. In the implementation, federated server 502 may build the federated model before receiving a query from participating members or in response to a query. The implementation of this invention is not intended to be limited to the manner in which federated server 502 obtains the principal feature models and worker models forming the entities in the subset group. In the implementation, model building module 516 of federated server 502 implements step 610 and stores the federated model in federated model module 517. In the implementation, the federated model stored by federated server 502 can be used by members of the dynamic virtual network of entity 700.

[0109] In this embodiment, each participating single-entity server (e.g., first entity server 504A) manages a cache of master features and worker models. In implementation, each participating single-entity server continuously or periodically calculates the accuracy of the active model (the model used by the entity) based on the cached data using model metrics according to step 607, continuously building new master features and worker models as needed based on changes to cached data blocks of the corresponding entity (e.g., data caches 511, 511', 511'), and at a rate greater than a threshold T. acc1The accuracy of the primary features and worker model is cached for use by the federated server 502 in generating the federated model. In the implementation, when the average accuracy of the primary features and worker model is less than a threshold T... acc1 In step 610, the federated server 502 utilizes the (hybrid) active model and the cached model. In an embodiment, the federated server 502 precisely classifies the hybrid active model and the cached model, and in step 610 selects the top S active models as a list of new active models to be used in the generated federated model. In various aspects of the invention, each entity server 504 assigns weights to the selected effective models based on the model's accuracy, or adjusts the model's weights using adjustment formula (2), or reuses previously assigned weights to the model. Illustrative examples of using federated master feature models to generate federated models are discussed below. Figure 10 The joint worker model is presented below as an illustrative example of generating joint models. Figure 11 Presented in the middle.

[0110] In step 611, the federated server 502 generates a response (joint prediction) using the appropriate federated model identified in step 610, and outputs a response to the participating members in response to the query received in step 609. In an embodiment, the federated model module 517 of the federated server 502 implements step 611.

[0111] Unless otherwise stated, Figure 6 The steps can be followed by Figure 6 The different sequences described herein. Furthermore, it should be understood that 504 responses are performed by multiple entity servers. Figure 6 The steps do not need to be executed simultaneously by each entity server. Instead, each individual entity server 504 can execute the indicated steps independently of each other.

[0112] Figure 7 It shows the basis Figure 6 A diagram illustrating the identification of the entity groups in steps 601 and 602. Figure 7 The steps indicated in the text can be found in Figure 5 Execute in the environment, and refer to Figure 5 The components described herein are described.

[0113] exist Figure 7 In an exemplary scenario, a federated server (e.g., Figure 5 The federated server 502 identifies a dynamic virtual network comprising five subset groups 702 of related entities 700. More specifically, the federated server 502 obtains common data from the first entity server 504A, the second entity server 504B, and the third entity server 504C, and generates corresponding relationship graphs 704A, 704B, and 704C. Figure 7As shown, each relationship graph for the primary single-entity participant identifies other single-entity participants (e.g., neighbors 706), features of other single-entity participants (e.g., features 707), and relationship parameters (e.g., relationships 708) that quantify the similarity between the features of the primary single-entity participant and the features of other single-entity participants. For example, relationship graph 704A indicates that the features F1, F2, and F3 of other entities B, C, and D result in: a relationship parameter of 0.992 between single entity A and single entity B; a relationship parameter of 0.927 between single entity A and single entity C; and a relationship parameter of 0.872 between single entity A and single entity D.

[0114] exist Figure 7 In the example, based on information obtained from a single entity AV, the relation mapping results in five distinct subset groups 702, including: entities B and V, entities E, G, U, and H (subset group 702A), entities A, C, and F (subset group 702B), entities K, and entity G. In this example, individual entities K and G do not have relation parameters that satisfy the minimum threshold required to group with another single entity participant. That is, the characteristics of single entities K and G are not sufficiently similar to the characteristics of the other single entity participants that federate server 502 groups them with.

[0115] Figure 8 This illustrates a worker model and a master feature model aggregated from a single entity, according to an embodiment of the present invention, for generation and caching. Figure 6 The model output shows the changes monitored at step 606. Figure 8 In the example, the machine learning execution environment 800 for an entity (e.g., entity A) includes a first worker model, a second worker model WW2, a third worker model WW3, and a principal feature model MW. The outputs of worker models WW1, WW2, and WW2 are provided to the principal feature model MW, as indicated at 802, and can also be used as input to other worker models, as indicated at 804. In the implementation, an entity (e.g., entity A) can generate predictions (e.g., responses to queries) based on its principal feature model and worker models. In the implementation, the principal response is predicted using a formula by applying the principal feature model; each worker response is predicted by applying the corresponding worker model, and the results from the principal feature model and worker models are aggregated by a single entity server (e.g., first entity server 504A) to obtain the final prediction using the following formula (3).

[0116] Formula (3): Prediction=MW*MR+∑ i＝1to S WW i *WR i

[0117] Among them WWi MR represents the adjusted weights of the i worker models, MR is the output (response) of the principal feature model, and WR is the output (response) of the principal feature model. i is the output (response) of the worker model, and S is the size of a subset of features, where i = 1 to S. In one instance, initial MW = 0.5 and initial WW i =0.17.

[0118] Figure 9 A data cache for a subgroup according to an embodiment of the present invention is shown, the data cache being configurable according to... Figure 6 Step 606 involves monitoring. Figure 9 The example describes a subset group 702B that includes entities A, C, and F. For example... Figure 9 As shown, the model output for new data blocks (e.g., block 1, block 2, block 3) is generated by the corresponding entities A, B, and C, and can be shared among the entities, for example, as indicated at 900. In this embodiment, the master feature and worker models of the corresponding entities A, B, and C utilize private data inputs to generate the model output. The new data is saved to at least one data cache 901, as indicated at 902. The new data blocks in at least one data cache 901 can be used by each entity A, B, and C to train the master feature and worker models for each entity, as indicated at 904. Since the local master feature and worker models are trained by entities A, C, and F, the model outputs of the entities are improved (providing more accurate responses / predictions). Therefore, the federated server 502 can utilize the updated / trained master feature and worker models of entities A, B, and C to generate a federated model 908, as discussed in more detail below.

[0119] Figure 10 It shows the basis Figure 6 The diagram showing the generation of the joint model 1000 in step 610. Figure 10 In this instance, the federated server 502 generates a configuration file for entities A, C, and F. Figure 7 The joint model 1000 is a subset group 702B of the dynamic virtual network of entity 700. Figure 10 The diagram illustrates the principal feature and worker model outputs e1, e2, and e3 generated from entities A, C, and F. These outputs can be shared among the entities for model training purposes. Each principal feature model (e.g., principal models 1 through 3) applies weights W to its parameters. i It also provides a weighted output indicated at 1002. In its implementation, the federated server 502 uses parallel computation of weight equations to combine all principal feature models of subset groups (e.g., 702B). Depending on performance costs and computational metrics, the formula can be stochastic gradient descent (SGD) or parametric averaging (in... Figure 10(Indicated at position 1004 in the text). In the implementation, the federated server 502 generates the federated model using the following parameter averaging formula (4).

[0120] Formula (4):

[0121] Figure 11 Showing according to Figure 6 Step 610 describes the use of the joint worker model. A joint machine learning model 1000 is used to construct the worker model using partial features. Figure 11 In the example, worker models FWW1, FWW2, and FW3 for the corresponding entities (e.g., A, F, and C) are used to generate the corresponding predictor sets 1-3. Figure 11 The worker model outputs e1, e2, and e3 generated by the workers (e.g., worker AC) of each entity are shown, which can be shared among entities for model training purposes. In an embodiment, the joint server 502 uses the following formula (5) to obtain joint predictions.

[0122] Formula (5):

[0123]

[0124] In this model, FMW is the joint model, MW is the weight of the master model, MR is the output of the master feature model, FWW is the combined / joint worker model, WW is the initial weight of the master feature model, and WR is the output of the worker model.

[0125] Figure 12 The workflow of a joint system of machine learning models according to various aspects of the present invention is illustrated. Figure 12 It shows Figure 6 The steps, and can be in Figure 5 Execution in environment 500 Figure 6 The steps. It should be understood that, Figure 12 The multiple iterations of the workflow described herein lead to the continuous learning of the machine learning model of this invention.

[0126] At the start of iteration 1200, the first entity server 504A of entity (e.g., entity A) collects or shares public information 1203 at 1202 about other participating entities (e.g., C and F in subset group 702B). The first entity server 504A can then, according to... Figure 6 Information is collected at step 600 at 1202. The first entity server 504A can store information about the entity's characteristics as a feature set 1204 in the database. When new information is collected at 1202, the first entity server 504A can identify new features 1205 to be added to the new master feature and worker model.

[0127] Still refer to Figure 12 At step 1206, the first entity server 504A constructs a principal feature model 1207, which combines all features of interest identified by the first entity server 504A. The joint server 504 can combine (jointly) the features from the relevant principal feature models 1207 using the parametric averaging integral 1208 to obtain a joint principal feature model for use in the joint model 1209. Step 1206 can be based on... Figure 6 Step 604 is implemented. The principal feature model 1207 for the entity can be retrained by the entity (e.g., first entity server 504A), as indicated at 1210. In the implementation, the entity selects a subset of features for partial computation and begins regression iteration. In the embodiment, the entity utilizes previous features of the principal feature model 1207, but collects more detailed information (e.g., private or sensitive information) at the entity location. Additional information may include, for example, values ​​of key parameters, business configuration information (e.g., financial, cloud usage, etc.), and / or, for example, information about the characteristics of the input data. In each respect, the entity (e.g., first entity server 504A) establishes a regression model of the relationship between features and targets. In the implementation, the entity (e.g., entity A) may utilize the following formula (6):

[0128] Formula (6): Y = F(X), where Y is the target value, X is the input feature value, and F is a function.

[0129] exist Figure 12 At position 1211, the first entity server 504A constructs multiple worker models 1212. Each worker model is established for a feature subset 1213, which includes a subset of the total features of the main feature model 1207. In the implementation, it can be based on... Figure 6 Step 603 is used to execute 1211. Figure 12 In the example, a worker model is built for features FM1, FM2, and FM3, where S is the size of the local feature subset, and S = 3. In the embodiment, a worker model is built for the key feature subset 1214, where key features are fixed features that are always used for modeling (as opposed to optional features that can be modeled). In the embodiment, a federated server (e.g., Figure 5 502) utilizes parameter averaging integration 1215 (i.e., a joint worker model from different entities) to combine features from worker model 1212 for use in joint model 1209. As described at 1216, and according to Figure 6 In step 608, the first entity server 504A can optimize the worker model by adjusting the weights of the worker model.

[0130] At step 1217, the first entity server 504A assigns initial weights to the main feature model and the worker model. Step 1217 can be based on... Figure 6 Step 605 is implemented. In Figure 12 In the example, the main feature model is assigned initial weights MW and the worker model has initial weights WW. n In this example, MW = e, where e is greater than zero but less than 1, and WW n = (1-e) / S. For example, when S = 3 and e = 0.5, MW = 0.5 and WW = 0.5. n =0.17.

[0131] In step 1218, the first entity server 504A adjusts the model weights as needed. Step 1218 can be based on... Figure 6 Step 608 is implemented. In the implementation, if the size of the entity's data cache meets the threshold trigger size, the first entity server 504A calculates the accuracy of the current main feature model and worker model, and adjusts the model weights according to the accuracy.

[0132] Advantageously, embodiments of the invention construct a dynamic virtual network of related entities to share separate machine learning models for these entities. In the implementation, at the feature level, relationships between dynamic feature weights are used to construct master feature models and worker models. In embodiments, at the model level, the joint distributed system learns continuously based on iterative computations from various sensitive data models.

[0133] In this embodiment, the service provider may provide the processes described herein to perform. In this case, the service provider may create, maintain, deploy, support, etc., computer infrastructure for one or more customers to perform the processing steps of this invention. These customers may be, for example, any business using the technology. In turn, the service provider may receive payments from consumers under subscription and / or fee agreements, and / or the service provider may receive payments from the sale of advertising content to one or more third parties.

[0134] In yet another embodiment, the present invention provides a method implemented via a networked computer. In this case, computer infrastructure, such as a computer system / server 12, can be provided. Figure 1 Furthermore, it is possible to obtain (e.g., create, purchase, use, modify, etc.) one or more systems for performing the processes of the present invention and deploy them to a computer infrastructure. In this regard, the deployment of the system may include one or more of the following: (1) from a computer-readable medium on a computer system / server 12 (e.g., Figure 1(1) Installing program code on a computing device (as shown); (2) Adding one or more computing devices to the computer infrastructure; and (3) Combining and / or modifying one or more existing systems of the computer infrastructure to enable the computer infrastructure to perform the process of the present invention.

[0135] Various embodiments of the invention have been described for illustrative purposes, but are not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope of the described embodiments. The terminology used herein has been chosen to best explain the principles of the embodiments, their practical application, or technical improvements to technologies found in the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

Claims

1. A method for generating a joint model, comprising: The computing device monitors changes in cached data of entities in a networked group of entities, wherein the cached data includes model output data from worker models and master feature models of the entities, wherein the worker models and master feature models include machine learning models, and wherein the master feature model includes all features in a feature set associated with the entity, and each worker model includes a subset of the feature set associated with the entity. The computing device iteratively updates the parameter weights of the worker model and the principal feature model based on the monitoring, thereby generating an updated worker model and an updated principal feature model; as well as The computing device provides the updated worker model and the updated master feature model to a remote federated server for use in a federated model that merges the updated worker model and the updated master feature model of the entity with other updated master feature models and other updated worker models of other entities in the entity's network group.

2. The method according to claim 1, further comprising: The worker model is established by the computing device; as well as The main feature model is established by the computing device.

3. The method of claim 1, further comprising generating a model output by the computing device using the parameter average integral of the principal feature model of the entity and the worker model.

4. The method of claim 1, further comprising assigning initial parameter weights to the worker model and the main feature model by the computing device.

5. The method according to claim 1, wherein, The model output data is generated from the main feature model and the worker model based on the private data input of the entity.

6. The method of claim 1, further comprising: The computing device sends the query from the participating members of the networked entity group to the federation server; as well as The computing device receives a response to the query from the federated server, wherein the response is based on the output of the federated model.

7. The method of claim 1, further comprising determining the accuracy of the worker model and the principal feature model of the entity by means of the computing device, wherein the iterative update of the parameter weights of the worker model and the principal feature model of the entity is further based on the accuracy of the principal feature model and the worker model of the entity.

8. A computer program product comprising program instructions executable by a computing device to: Changes in cached data of entities in a networked entity group are monitored, wherein the cached data includes output data from worker models and master feature models of the entities, wherein the worker models and the master feature models include machine learning models, wherein the master feature models include all features in a feature set associated with the entities, and each worker model includes a subset of the feature set associated with the entities. Based on the monitoring, the parameter weights of the worker model and the main feature model are iteratively updated to generate an updated worker model and an updated main feature model. as well as The updated master feature model and the updated worker model are provided to a remote federation server for use in a federation model that merges the updated master feature model and the updated worker model of the entity with other updated master feature models and other updated worker models of other entities in the entity's network group.

9. The computer program product according to claim 8, wherein, The program instructions are further executed by the computing device to: Generate a vector graph representing the relationships between entities in the networked entity group based on the features of the corresponding entities; and The related entity group is identified based on the vector graph, wherein the networked entity group includes the related entity group, and wherein each entity in the related entity group is associated with a feature set.

10. The computer program product according to claim 9, wherein, The program instructions are further executed by the computing device to identify the characteristics of the multiple remote entities based solely on common information of the multiple remote entities.

11. The computer program product according to claim 8, wherein, The program instructions are further executed by the computing device to: Establish the worker model; and Establish the main feature model.

12. The computer program product according to claim 8, wherein, The program instructions are further executed by the computing device to generate model output based on the worker model and the principal feature model of the entity.

13. The computer program product according to claim 8, wherein, The program instructions are further executed by the computing device to assign initial parameter weights to the worker model and the main feature model of the entity.

14. The computer program product according to claim 8, wherein, The model output data from the worker model and the master feature model is generated based on the private data input of the entity.

15. The computer program product according to claim 8, wherein, The program instructions can be further executed by the computing device to: The query is sent from the participating members of the networked entity group to the federation server; and Receive a response to the query from the federated server, wherein the response is based on the output of the federated model.

16. The computer program product of claim 8, wherein the joint model is generated by the parametric average integral of the updated principal feature model and the updated worker model of the entity and the other updated principal feature models and the other updated worker models of the other entities in the networked group of the entity.

17. A computer system, comprising: A processor, a computer-readable storage device, one or more computer-readable storage media, and program instructions commonly stored on the one or more computer-readable storage media, the program instructions being executable by the federated server to: Receive queries from participating members of the networked entity group; A joint model is generated based on the main feature model and worker model of the corresponding entities in the networked entity group; A response to the query is generated based on the output of the joint model; as well as Send a response to the query to the participating member, wherein: The main feature model includes all features of the corresponding entity in the networked entity group. Each worker model includes a subset of all features of the corresponding entity in the networked entity group; as well as The main feature model and the worker model are iteratively updated by the corresponding entities based on private data that is inaccessible from the federated server.

18. The computer system of claim 17, wherein generating the joint model comprises the parametric average integral of the principal feature model and the worker model of the respective entity.

19. The computer system according to claim 17, wherein, The federated server includes software provided as a service in a cloud environment.

20. The computer system according to claim 17, wherein, The program instructions are further executed by the federated server to: Generate a vector graph representing the relationships between multiple remote entities based on public information; and The networked entity group is identified from multiple remote entities based on the vector graph.

Images