Collaborative training of machine learning models

Abstract

The present invention provides a federation model based on a locally trained machine learning model. In an embodiment, a method includes: monitoring, by a computing device, cached data of an entity in a group of networked entities for changes in the data, the cached data including model output data from a worker model and a master feature model of the entity, the worker model and the master model including the machine learning model; 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 federation model that incorporates the entity's updated worker model and updated master feature model into other updated master feature models and other updated worker models of other entities in the group of networked entities.

Description

[Technical Field]

[0001] Aspects of the present invention relate generally to machine learning, and more particularly to collaborative training of machine learning modules. [Background technology]

[0002] Generally, machine learning is when a computer uses algorithms or statistical models to analyze and infer patterns in data in order to learn and adapt 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. Machine learning models can learn and adapt over time using input data from a specific domain (e.g., a subject area). Data privacy concerns may limit the amount of data available to a computer system, which may therefore affect the quality or quantity of data available to train and / or update machine learning models.

[0003] Federated Architecture (FA) is an enterprise architecture pattern that enables interoperability and information sharing among semi-autonomously and decentralized organized lines of business (LOBs), information technology systems, and applications. Federated learning is a machine learning technique that trains algorithms across multiple distributed edge devices or servers that hold local data samples without exchanging data samples. This approach differs from traditional centralized machine learning techniques, which upload all local datasets to a single server. Generally, federated learning allows multiple actors to build a common machine learning model without sharing data. In one federated approach, each party jointly trains a global machine learning model with the help of a centralized aggregator by exchanging summaries of their individual data. Although only summaries of the parties' data are shared, the summaries may still reveal important personal or confidential information. Therefore, there is a need for a system and method that addresses data privacy concerns while enabling the building and training of machine learning models utilizing the private data of multiple participants. Summary of the Invention

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

[0005] In implementations, model output data from the master feature model and worker models is generated based on private data input by the entities. Thus, embodiments of the present invention enable federated models to utilize master feature models and worker models generated based on private data input by the respective entities without needing to access the private data.

[0006] In an embodiment, the method further includes determining, by the computing device, the accuracy of the worker model and the master feature model of the entity. In an embodiment, iteratively updating the parameter weights of the worker model and the master feature model of the entity is further based on the accuracy of the master feature model and the worker model of the entity. Thus, an embodiment of the present invention provides a collaboration server having worker models and master feature models that are updated based on the accuracy, thereby improving the accuracy of collaboration models that utilize the updated worker models and master feature models.

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

[0008] In embodiments, model output data from the worker model and the master feature model are generated based on private data input by the entities. Thus, embodiments of the present invention enable federated models to utilize master feature models and worker models that are generated based on private data input by the respective entities.

[0009] In another aspect of the present invention, there is a system including a processor, a computer-readable memory, one or more computer-readable storage media, and program instructions collectively stored on the one or more computer-readable storage media. The program instructions are executable by a coordination server to cause the coordination server to receive a query from a participating member of a group of networked entities. The program instructions are further executable to generate a coordination model based on the master feature model and the worker model of each entity in the group of networked entities. Additionally, the program instructions are executable to generate a response to the query based on an output of the coordination model. Furthermore, the program instructions are executable to send the response to the query to the participating member. The master feature model each includes all features of each entity in the group of networked entities. The worker models each include a subset of all features of each entity in the group of networked entities. Furthermore, the master feature model and the worker model are iteratively updated by each entity based on private data inaccessible by the coordination server. Advantageously, such a system enables the coordination server to respond to queries based on models of multiple participating entities without accessing the entities' private data.

[0010] In an embodiment, the program instructions of the system further include: Collaboration Server and Collaboration Serverand generating a vector map representing relationships between the plurality of remote entities based on the public information. In an embodiment, the program instructions are further executable to identify groups of networked entities from the plurality of remote entities based on the vector map. Thus, embodiments of the present invention build a network of related entities in which master feature models and worker models can be utilized in a federation model available to participating members of the network.

[0011] Aspects of the present invention are explained in the following detailed description by way of non-limiting examples of illustrative embodiments of the invention and with reference to the several annotated drawings in which: [Brief explanation of the drawings]

[0012] [Figure 1] FIG. 2 illustrates a cloud computing node according to one embodiment of the present invention. [Figure 2] FIG. 1 illustrates a cloud computing environment according to one embodiment of the present invention. [Figure 3] FIG. 2 illustrates abstraction model layers according to one embodiment of the present invention. [Figure 4] FIG. 1 illustrates an exemplary environment in which the flow of data between entities is restricted by governance rules. [Figure 5] FIG. 1 is a block diagram of an exemplary environment in accordance with an aspect of the present invention. [Figure 6] 1 is a flowchart of an exemplary method according to an aspect of the present invention. [Figure 7] FIG. 1 illustrates identifying entity groups according to an aspect of the invention. [Figure 8] FIG. 1 illustrates the aggregation of worker models and master feature models by a single entity in accordance with an aspect of the present invention. [Figure 9] FIG. 10 illustrates a subset group data cache in accordance with an aspect of the present invention. [Figure 10] FIG. 1 illustrates the generation of a federation model according to aspects of the present invention. [Figure 11] FIG. 1 illustrates the use of a collaborative worker model in accordance with aspects of the present invention. [Figure 12] FIG. 1 illustrates a workflow in a machine learning model collaboration system according to an aspect of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0013] Aspects of the present invention relate generally to machine learning, and more particularly to collaborative training of machine learning modules. According to aspects of the present invention, a system is provided for setting up a master feature-level model (hereinafter referred to as master feature model) and worker feature-level models (hereinafter referred to as worker models) along with a collaborative model-level dynamic virtual learning network of individual entities for accurate prediction on sensitive data.

[0014] There is an increasing use and development of computer systems that utilize machine learning models to learn and adapt without following explicit instructions. Concerns about using data to update or improve machine learning models over time include data availability and data privacy and confidentiality issues. Data privacy may be governed by individual or corporate preferences or by government regulations. For example, the General Data Protection Regulation (GDPR) is a European Union law related to data privacy and security. Data privacy concerns may limit the amount of data available to computer systems, which may therefore affect the quality or quantity of data available to train and / or update machine learning models.

[0015]

[0006] Embodiments of the present invention implement a technical solution for solving the technical problem of building and updating machine learning models when data access is limited by the availability of private or confidential data. In an implementation, a computer server builds a dynamic virtual network of entities by calculating public (non-private) characteristics of each entity to group the individual entities into multiple virtual, temporary organizations or groups. Public characteristics include, but are not limited to, the entity's size, characteristics of the entity's owner, entity statistics, or other types of information the entity is permitted to share, or a combination thereof. In an implementation, the computer server converts entity information into mathematical vectors using natural language processing, such as the word2vec algorithm, which is a natural language processing algorithm that uses neural network models to learn word associations from large text corpora. In an embodiment, the computer server calculates the vector distance of each entity and then groups the entities with the closest distance into temporary organizations or groups containing a high number of similar entities (high-similarity entities). Data from entities within a particular temporary organization can be used to drive machine learning.

[0016] In an embodiment, for each virtual network or subset group, a computer server constructs a master feature model and multiple worker models and aggregates the results in relation to dynamic feature weights. In an implementation, the master feature model is used to evaluate all private features of the entity and can retain global data. However, the master feature model may require a relatively large amount of data for refresh or update, making it inconvenient for use in continuous learning. Each worker model contains partial private features and utilizes minimal data for continuous learning as a supplement to the master feature model, making it relatively easy to refresh / update. In an embodiment, a computer server (e.g., an entity server) aggregates the master feature model and worker models to enable multidimensional private feature learning. In an implementation, the weights of the aggregated feature model are assigned by the entity as initial values, but the values ​​will change dynamically through caching of continuous data streams.

[0017] In an aspect of the present invention, the aggregated models (e.g., master feature model and worker models) are adjusted by the entity because the private features of the learning object may change at any time. For example, private features (private data) that may change over time include, but are not limited to, environment upgrades, feature scale, and data distribution. In an embodiment, retraining involves new models, but with the same feature set, or new master feature models or worker models with entirely new feature sets. In an embodiment, a computer server (e.g., an entity server) sorts the retrained new models by model metrics and then selects the top N models as the new master feature model and worker model set. In an implementation, the computer server also adjusts the model weights in the model metric analysis formula.

[0018] In an embodiment, a collaboration server collaborates the master feature models and worker models of entities into a collaboration virtual network model (a collaboration model) configured to predict the final result for a user query. In an implementation, the collaboration server identifies all master feature models and worker models of related entities in the dynamic virtual network of entities. In an embodiment, the collaborative learning utilizes a parallel computation weight equation to combine all entity models. The parallel computation weight equation can be asynchronous stochastic gradient descent (SGD) or parameter averaging, which depends on performance cost and computing metrics.

[0019] Based on the above, it will be appreciated that implementations of the present invention utilize federated learning to generate a master machine learning model (e.g., a federated model) based on models from individual entities in a network, which can be utilized to answer queries for members of the network without obtaining private data directly from the individual entities in the network. Thus, embodiments of the present invention utilize a technical solution that includes the generation of a master machine learning model to address the technical problem of building and updating machine learning models when data access is limited by privacy or confidentiality concerns.

[0020] To the extent implementations of the present invention collect, store, or use personal information provided by or obtained from individuals (e.g., personal data of entity members), it is understood that such information will be used in accordance with all applicable laws regarding the protection of personal information. Additionally, the collection, storage, and use of such information may require the individual's consent to such activities, for example, through an "opt-in" or "opt-out" process, depending on the circumstances and type of information. Personal information may be stored and used in a secure manner appropriate to the type of information, for example, through various encryption and anonymization techniques.

[0021] The present invention may be a system, method, or computer program product, or combination thereof, integrated at any possible level of technical detail. The computer program product may include a computer-readable storage medium having stored thereon computer-readable program instructions for causing a processor to carry out aspects of the present invention.

[0022] A computer-readable storage medium may be a tangible device capable of retaining and storing instructions for use by an instruction execution device. The computer-readable storage medium may be, by way of example only, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or a suitable combination thereof. More specific examples of computer-readable storage media include portable computer diskettes, hard disks, RAM, ROM, EPROM (or flash memory), SRAM, CD-ROMs, DVDs, memory sticks, floppy disks, mechanically encoded devices having instructions recorded thereon, such as punch cards or ridge-in-groove structures, and suitable combinations thereof. As used herein, a computer-readable storage medium should not be construed as a transitory signal per se, such as an electric wave or other freely propagating electromagnetic wave, an electromagnetic wave propagating through a waveguide or other transmission medium (e.g., light pulses passing through a fiber optic cable), or an electrical signal transmitted over a wire.

[0023] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each 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, or a wireless network, or a combination thereof). The network may be comprised of copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium within the respective computing / processing device.

[0024] Computer-readable program instructions for carrying out operations of the present invention may be either source code or object code written in any combination of one or more programming languages, including assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, configuration data for integrated circuits, or object-oriented programming languages ​​such as Smalltalk, C++, etc., and procedural programming languages ​​such as the "C" programming language and similar programming languages. The computer-readable program instructions may be executed entirely on the user's computer, as a standalone software package, or partially on the user's computer. Alternatively, the computer may be executed partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, 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, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA) can execute computer-readable program instructions by utilizing state information of the computer-readable program instructions to personalize the computer-readable program instructions in order to carry out aspects of the present invention.

[0025] Aspects of the present invention are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will 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.

[0026] These computer-readable program instructions can be provided to a processor of a computer or other programmable data processing apparatus to create a machine, such that the instructions, executed by the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. These computer-readable program instructions can also be stored in a computer-readable storage medium connectable to a computer, programmable data processing apparatus, or other device, or combination thereof, that functions in a particular way, such that the computer-readable storage medium on which the instructions are stored constitutes one of several products including instructions that implement aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0027] Computer-readable program instructions, such as instructions to perform the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams on a computer, other programmable apparatus, or other device, can also be loaded into a computer, other programmable data processing apparatus, or other device to perform a series of operational steps on the computer, other programmable apparatus, or other device to produce a computer-implemented process.

[0028] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of executable implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or portion of instructions, which constitute one or more executable instructions for implementing the specified logical function(s). In some alternative embodiments, the functions shown in the blocks may occur out of the order shown in the figures. For example, two blocks shown in succession may actually be accomplished as a single step, executed concurrently, substantially concurrently, partially, or fully in a time-overlapping manner, or the blocks may be executed in the reverse order depending on the functionality involved. It should also be noted that each block of the block diagrams and / or flowchart diagrams, and combinations of blocks in the block diagrams and / or flowchart diagrams, can be implemented by a special-purpose hardware-based system that performs the specified functions or operations or executes a combination of special-purpose hardware and computer instructions.

[0029] Although this disclosure includes detailed descriptions of cloud computing, it should be understood that implementation of the teachings described herein is not limited to a cloud computing environment. Rather, embodiments of the present invention may be practiced in conjunction with any other type of computing environment now known or later developed.

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

[0031] The characteristics are as follows:

[0032] On-Demand Self-Service: Cloud consumers can unilaterally provision computing capacity, such as server time or network storage, automatically as needed, without the need for human interaction with the service provider.

[0033] Broad network access: Computing power is available over the network and can be accessed through standard mechanisms, facilitating use by heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, personal digital assistants (PDAs)).

[0034] Resource Pooling: Computing resources from a provider are pooled and offered to multiple consumers using a multi-tenant model. Various physical and virtual resources are dynamically allocated and reallocated based on demand. Consumers generally have no control or knowledge of the exact location of the resources they are provided with, resulting in a sense of location independence. However, consumers may be able to determine location at a higher level of abstraction (e.g., country, state, data center).

[0035] Rapid Elasticity: Computing capacity can be provisioned quickly and elastically, sometimes automatically, to instantly scale out and quickly release to instantly scale in. To the consumer, the computing power available for provisioning often appears unlimited, and can be purchased at any time and in any quantity.

[0036] Metered Services: Cloud systems leverage measurement capabilities at a level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, active user accounts) to automatically control and optimize resource usage. Resource usage can be monitored, controlled, and reported to provide transparency to both providers and consumers of utilized services.

[0037] The service model is as follows:

[0038] Software as a Service (SaaS): The functionality offered to the consumer is the availability of a provider's applications running on a cloud infrastructure that can be accessed from a variety of client devices through a thin client interface such as a web browser (e.g., webmail). The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or even individual application functionality, except for limited user-specific application configuration settings.

[0039] Platform as a Service (PaaS): The capability offered to consumers is to deploy applications they create or acquire using programming languages ​​and tools supported by the provider onto a cloud infrastructure. The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, or storage, but does have control over the deployed applications and, in some cases, the configuration of their hosting environment.

[0040] Infrastructure as a Service (IaaS): The functionality offered to consumers is the provisioning of processors, storage, networking, and other basic computing resources onto which they can deploy and run any software, which may include operating systems and applications. The consumer does not manage or control the underlying cloud infrastructure, but has control over the operating system, storage, and deployed applications, and in some cases partial control over some network components (e.g., host firewalls).

[0041] The deployment model is as follows:

[0042] Private Cloud: This cloud infrastructure is dedicated to a specific organization and can be managed by that organization or a third party, and can exist on-premise or off-premise.

[0043] Community Cloud: This cloud infrastructure is shared by multiple organizations to support a specific community with common concerns (e.g., mission, security requirements, policies, and compliance). This cloud infrastructure can be managed by those organizations or a third party and can exist on-premises or off-premises.

[0044] Public cloud: This cloud infrastructure is available to the general public or large industry organizations and is owned by an organization that sells cloud services.

[0045] Hybrid cloud: This cloud infrastructure combines two or more cloud models (private, community, or public), each of which retains its inherent nuances but is bound by standards or specific technologies that enable data and application portability (e.g., cloud bursting for load balancing between clouds).

[0046] A cloud computing environment is a service-oriented environment that emphasizes statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing is an infrastructure that includes a network of interconnected nodes.

[0047] 1, a schematic diagram of an example cloud computing node is shown. Cloud computing node 10 is merely one example of a suitable cloud computing node and is not intended to suggest any limitation as to the scope of use or functionality of the embodiments of the present invention described herein. Nevertheless, cloud computing node 10 is capable of implementing and / or performing any of the functionality defined herein.

[0048] In cloud computing node 10, computer system / server 12 is operable in numerous other general-purpose or special-purpose computing system environments or configurations. Examples of well-known computing systems, environments, or configurations, or combinations thereof, that may be suitable for use with 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 above systems or devices.

[0049] The computer system / server 12 may be described in the general context of computer system-executable instructions, such as program modules, executed by a computer system. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc. that perform particular tasks or implement particular data types. The computer system / server 12 may be practiced in a distributed cloud computing environment where tasks are performed by remote processing devices that are linked through a communications network. In a distributed cloud computing environment, program modules may be stored in both local and remote computer system storage media, including memory storage devices.

[0050] 1, computer system / server 12 in cloud computing node 10 is depicted as a general-purpose computer device. Examples of components of computer system / server 12 include, but are not limited to, one or more processors or processing units 16, system memory 28, and a bus 18 connecting various system components including system memory 28 to processor 16.

[0051] Bus 18 represents any one or more of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example, such architectures include an Industry Standard Architecture (ISA) bus, a MicroChannel Architecture (MCA) bus, an Enhanced ISA (EISA) bus, a Video Electronics Standards Association (VESA) local bus, and a Peripheral Component Interconnect (PCI) bus.

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

[0053] The system memory 28 may include a computer system-readable medium such as a random access memory (RAM) 30 or a cache memory 32, or both, in the form of a volatile memory. The computer system / server 12 may also include other removable / non-removable and volatile / non-volatile computer system-readable media. As an example, the storage system 34 may be provided for reading from and writing to a non-removable, non-volatile magnetic medium (not shown, commonly referred to as a "hard drive"). Also, although not shown, a magnetic disk drive for reading from and writing to a removable, non-volatile magnetic disk (e.g., a floppy disk) and an optical disk drive for reading from and writing to a removable, non-volatile optical disk (e.g., a CD-ROM, DVD-ROM, or other optical media) may be provided. In these examples, each may be connected to the bus 18 by one or more data medium interfaces. As further shown and described below, the memory 28 may include at least one program product having a set (e.g., at least one) of program modules configured to perform the functions of embodiments of the present invention.

[0054] A program / utility 40 having a set (at least one) of program modules 42 may be stored in memory 28, as may an operating system, one or more application programs, other program modules, and program data. Each of the operating system, one or more application programs, other program modules, and program data, or some combination thereof, may include an implementation of a network environment. The program modules 42 generally perform the functions and / or methods of embodiments of the present invention described herein.

[0055] The computer system / server 12 may communicate with one or more external devices 14, such as a keyboard, pointing device, display 24, one or more devices that allow a user to interact with the computer system / server 12, or any device (e.g., a network card, modem, etc.) that allows the computer system / server 12 to communicate with one or more other computer devices, or a combination thereof. Such communication may occur via an input / output (I / O) interface 22. Additionally, the computer system / server 12 may communicate with one or more networks (e.g., a local area network (LAN), a general wide area network (WAN), or a public network (e.g., the Internet), or a combination thereof) via a network adapter 20. As shown, the network adapter 20 may communicate with other components of the computer system / server 12 via a bus 18. Although not shown, other hardware and / or software components may be used with the computer system / server 12, such as microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, data archive storage systems, etc.

[0056] Referring now to FIG. 2, an exemplary cloud computing environment 50 is depicted. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10 with which local computing devices used by cloud consumers can communicate, such as, for example, a personal digital assistant (PDA) or mobile phone 54A, a desktop computer 54B, a laptop computer 54C, or an automobile computer system 54N, or a combination thereof. The nodes 10 may communicate with each other. They may be grouped (not shown) physically or virtually in one or more networks, or combinations thereof, such as private, community, public, or hybrid clouds as described herein. This enables the cloud computing environment 50 to provide infrastructure, platform, or software, or a combination thereof, as a service without the cloud consumer having to maintain resources on their local computing devices. The types of computing devices 54A-N depicted in FIG. 2 are intended for illustrative purposes only, and it will be understood that the computing nodes 10 and the cloud computing environment 50 can communicate with any type of computerized device over any type of network or network-addressable connection (e.g., using a web browser), or both.

[0057] Referring to Figure 3, a set of functional abstraction model layers provided by cloud computing environment 50 (Figure 2) is shown. It should be understood in advance that the components, layers, and functions shown in Figure 3 are merely exemplary, and embodiments of the present invention are not limited thereto. As shown, the following layers and corresponding functions are provided:

[0058] Hardware and software layer 60 includes hardware and software components. Examples of hardware components include mainframe 61, reduced instruction set computer (RISC) architecture-based server 62, server 63, blade server 64, storage device 65, and network and network components 66. In some embodiments, software components include network application server software 67 and database software 68.

[0059] The virtualization layer 70 provides an abstraction layer from which the following virtual entities can be provided, for example: virtual servers 71, virtual storage 72, virtual networks including virtual private networks 73, virtual applications and operating systems 74, and virtual clients 75.

[0060] By way of example, the management layer 80 may provide the following functions: Resource provisioning 81 enables dynamic procurement of computing and other resources utilized to execute tasks within the cloud computing environment; Metering and pricing 82 enables cost tracking as resources are utilized within the cloud computing environment and billing or invoicing for the consumption of these resources; By way of example, these resources may include application software licenses; Security enables identification and verification of cloud consumers and tasks, as well as protection for data and other resources; User portal 83 provides consumers and system administrators with access to the cloud computing environment; Service level management 84 enables allocation and management of cloud computing resources so that requested service levels are met; Service level agreement (SLA) planning and fulfillment 85 enables advance arrangement and procurement of anticipated future cloud computing resources required in accordance with SLAs.

[0061] The workload layer 90 provides examples of functionality available to a cloud computing environment. Examples of workloads and functionality that can be provided from this layer include mapping and navigation 91, software development and lifecycle management 92, virtual classroom instruction delivery 93, data analytics processing 94, transaction processing 95, and federated model training 96.

[0062] An implementation of the invention may include the computer system / server 12 of Figure 1 in which one or more of the program modules 42 are configured to perform (or cause the computer system / server 12 to perform) one or more functions of federation model training 96 of Figure 3. For example, one or more of the program modules 42 may be configured to: collect public information from participating entities, identify a group of related entities, build worker and master feature models for each entity in the group of related entities, monitor the entities' data caches for changes indicative of changes to private information, update or train the worker and master feature models at the entities, generate a federation model based on the updated worker and master feature models, and generate responses to user queries utilizing the federation model.

[0063] FIG. 4 illustrates an exemplary environment 400 in which the flow of data between entities is restricted by governance rules. As shown, in step 1, Entity A (a first data controller) creates Data 1. In a typical unrestricted data exchange, in step 2, Entity A transfers Data 1 to Entity B (a 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. In the scenario of FIG. 4, the data flow from Entity A to Entity B is restricted by governance rules (e.g., GDPR rules) in 401. Similarly, the data flow from Entity B to Entity A is restricted by governance rules in 402. In this scenario, model training at Entity A and B is not possible due to a lack of sufficient training data. Embodiments of the present invention provide a technical solution to this technical problem by generating a federated model for use by multiple entities.

[0064] 5 is a block diagram of an exemplary environment 500 according to an aspect of the present invention. In an embodiment, the environment 500 includes a network 501 connecting a cooperation server 502 to a plurality of single-entity servers 504, represented by a first entity server 504A, a second entity server 504B, and a third entity server 504C. Each of the single-entity servers 504 may include one or more computing systems (e.g., computer system 12 of FIG. 1). In an embodiment, the single-entity servers 504 each include one or more computing nodes 10 in the cloud computing environment 50 of FIG. 2. In an embodiment, one or more of the single-entity servers 504 include special-purpose computing devices configured to utilize machine learning techniques to generate and update machine learning models.

[0065] The network 501 may be any suitable communication network or combination of networks, such as a local area network (LAN), a general wide area network (WAN), or a public network (e.g., the Internet), or a combination thereof. In an implementation, the collaboration server 502 provides services to participating users in the cloud network.

[0066] In embodiments, the term single entity as used herein refers to an entity that is governed by different sets of rules and / or regulations, such as, for example, a corporation, a subsidiary, a non-profit organization, or a government agency. In embodiments, each entity is a single entity that is governed by data sharing rules (e.g., policies, rules, or laws, or a combination thereof, restricting the flow of data between entities) that prevent the sharing of certain types of data with other entities.

[0067] In an implementation, each entity server 504 is in direct or indirect communication 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., computer system 12 of FIG. 1 ) and may be, for example, a desktop computer, a laptop computer, a tablet, a smartphone, or other personal computing device. In an embodiment, the entity devices 505 each include one or more computing nodes 10 in the cloud computing environment 50 of FIG. 2 .

[0068] 5, each entity server 504 may include one or more program modules (e.g., program module 42 of FIG. 1) configured to be executed by the entity server 504 and 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), represented by 510, 510′, and 510″, configured to retrieve and / or transfer data between the entity server's 504 data cache (represented by 511, 511′, and 511″) and other entity servers 504 and / or collaboration servers 502, and a machine learning (ML) module (e.g., program module 42), represented by 512, 512′, and 512″, configured to train master feature models and worker models using data from one or more entity servers 504 and generate model output data using the locally trained master feature models and worker models. In an implementation, entity server 504 is configured to collect data (eg, data about features) from data stores represented in FIG. 5 as 513, 513', and 513''.

[0069] 5, the federation server 502 may include one or more program modules (e.g., program module 42 of FIG. 1 ) configured to be executed by the federation server 502 and to perform one or more functions described herein. In an embodiment, the federation 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, which may be stored in a database 515; a model building module 516 configured to generate a federation model from multiple master feature models and worker models; and a federation model module 517 configured to obtain user queries and generate and output answers to the user queries (e.g., queries from the entity servers 504 or entity devices 505, or both). In an implementation, the federation model module 517 is configured to answer questions in one or more subject domains and is made available to members of a dynamic virtual network of entities identified by the federation server 502, in accordance with an embodiment of the present invention.

[0070] In embodiments, the separate modules described above may be combined into a single module. Additionally, or alternatively, the single module described above may be implemented as multiple modules. Furthermore, the quantity of devices and / or networks in environment 500 is not limited to those shown in FIG. 5. In practice, environment 500 may include additional devices and / or networks, fewer devices and / or networks, different devices and / or networks, or devices and / or networks arranged differently from those illustrated in FIG. 5.

[0071] 6 is a flowchart of an exemplary method according to an embodiment of the present invention. The steps of the method may be performed in the environment of FIG. 5 and will be described with reference to elements depicted in FIG.

[0072] <Identifying the dynamic virtual network of an entity> In step 600, each participating single-entity server (e.g., first entity server 504A) and / or coordination server 502 collects public information from multiple single-entity participants (e.g., via participating single-entity servers 504) and stores the information in a database (e.g., shared information module 510). As used herein, the term public information refers to information that is not subject to restrictive sharing policies, rules, or regulations. For example, public information as used herein may be information about a single-entity participant that is private, confidential, or not restricted from being disseminated to other entities. Conversely, the term private data as used herein refers to information that is subject to restrictive sharing policies, rules, or regulations. For example, private data as used herein may include information of an entity that is private, confidential, or restricted from being disseminated to other entities.

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

[0074] In an embodiment, in step 601, a single-entity server (e.g., the first entity server 504A hereinafter) or the collaboration server 502 generates a vector map for each single-entity participant, where the vector map represents the relationships between the single-entity participant and other single-entity participants based on the features identified in step 600 (e.g., the public information collected in step 600). In an aspect of the present invention, the first entity server 504A or the collaboration server 502 uses natural language processing, such as the word2vec algorithm, to generate the vector map. In an embodiment, the first entity server 504A or the collaboration server 502 calculates the vector distance of each entity based on the vector map, and then groups the entities with the closest distance into temporary organizations or subset groups containing a number of entities with a high similarity (e.g., related entities). In an embodiment, the first entity server 504A or the collaboration server 502 applies different weights to different features when generating the vector map. In an embodiment, the first entity server 504A or the collaboration server 502 uses the following vector equation (1) to generate the vector map:

[0075] TIFF0007828702000001.tif8150

[0076] TIFF0007828702000002.tif43167

[0077] In step 602, in an embodiment, the first entity server 504A or the collaboration server 502 identifies groups of related entities (subset groups). In an implementation, the first entity server 504A or the collaboration server 502 identifies the subset groups based on the vector map generated in step 601. In an aspect, a dynamic virtual network of entities including multiple subset groups is identified by the first entity server 504A or the collaboration server 502 based on the vector map of step 601. In an implementation, the first entity server 504A or the collaboration server 502 calculates vector distances between entities and groups entities with the closest distances into temporary organizations (subset groups) containing highly similar entities. In an embodiment, the entities are grouped based on stored rules (e.g., threshold vector distances). In an embodiment, a shared information module (e.g., 510) of the first entity server 504A performs step 602. In an alternative embodiment, the data collection module 514 of the collaboration server 502 implements step 602. An illustrative example of step 602 is shown in FIG. 7, described below.

[0078] It should be understood that steps 600-602 may be repeated periodically, and that the subset groupings in the dynamic virtual network of entities may change over time (e.g., new groupings may be added or removed) as one or more characteristics of a single entity change. In an embodiment, the first entity server 504A or the coordination server 502 issues notifications to participating entities indicating groups of related entities (subset groups). Notifications may be issued when changes are made to one or more of the subset groups or when subset groups are added or removed.

[0079] <Generating master feature models and worker models> In step 603, each participating single entity server (e.g., first entity server 504A) of each entity (e.g., A, C, and F in FIG. 7) in the subset group (e.g., 702A in FIG. 7) builds multiple worker models (machine learning models) for a subset of features in the master feature model. In implementations, different worker models may be based on different business transaction types, employee work sites, etc. In an embodiment, the first entity server 504A builds S worker models using a subset of the features in the master feature model, where S = the size of the partial feature subset. For example, when S = 3, the worker models build S worker models using features from the master feature model (e.g., 702A in FIG. 7). F1 , F2 and F3 ) In an implementation, the worker model includes fixed key features such as financial status, business revenue, etc., or optional features such as metadata, parameters, etc., or both. Various model building tools may be utilized to build the worker model, and implementations of the inventions herein are not intended to be limited by the method utilized to build the machine learning model. In an embodiment, an ML module (e.g., ML module 512) of each entity server (e.g., first entity server 504A) implements step 603.

[0080] In step 604, each participating single entity server (e.g., first entity server 504A) of each entity (e.g., A, C, F in FIG. 7) in the subset group (e.g., 702A in FIG. 7) builds a master feature model (machine learning model) having all features (e.g., F1, F2, F3 in FIG. 7) of the worker models. Various model building tools may be used to build master feature models for all features of interest (e.g., features for which information was collected in step 600), and embodiments of the invention herein are not intended to be limited by the method used to build the machine learning model. In an embodiment, the ML module (e.g., ML module 512) of each entity server (e.g., first entity server 504A) performs step 604.

[0081] In one example, the data store (e.g., 513) of a first worker device (e.g., one of entity devices 505A) includes data regarding the following database statistical features used to construct a first worker model: table cardinality, page number, and access frequency. In this example, the data store of a second worker device includes data regarding the following database statistical features used to construct a second worker model: index level, I / O speed, and access frequency. Furthermore, in this example, the data store of a third worker device includes data regarding the following database statistical features used to construct a third worker model: leaf page, page number, and system cache. In this example, some of the features of the first, second, and third worker models overlap. Thus, the master feature model will consider all of the above features of the individual worker models. Thus, each of the worker models considers a partial feature set or subset of all features considered by the master feature model, as shown in the exemplary master feature table for entities A, C, and F of the subset group (e.g., 702B in FIG. 7). [Table 1]

[0082] Table 1 is an exemplary feature table showing the features of the master feature model.

[0083] In step 605, each participating single entity server (e.g., the first entity server 504A) of each entity (e.g., A, C, and F) in the subset group (e.g., 702A) assigns weights (aggregation weights) to the outputs of the master feature model and the worker models. In one example, the first entity server 504 assigns a master feature model output weight of 0.5 and a worker model output weight of 0.17 to worker model n. The initial assignment of weights by the entity server may be based on predetermined default weights, predetermined rules, or may be assigned manually.

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

[0085] <Local Training> In step 606, each participating single entity server (e.g., first entity server 504A) identifies changes to one or more data caches (e.g., 511, 511′, 511″) based on its monitoring of the data caches. In an embodiment, the cached data of a participating entity (e.g., A, C, and F of subset group 702A in FIG. 7 ) includes model output data from the respective entity's aggregated master feature model and worker models, or model output data from another participating entity, or both. The data changes may include, for example, information about input data characteristics, values ​​of key parameters, information about selected businesses, and observed responses. In one example, the first entity server 504A includes rules that specify the types or categories of information to be monitored for changes, such that any change to the monitored information in a data cache (e.g., 511) triggers an evaluation of the accuracy of the cached data in step 607. In an implementation, the cached data relates to private data but does not disclose the private data. In an aspect of the invention, each participating single-entity server 504 identifies changes to cached data that indicate changes in private data (private data input to the master feature model and worker models) on the entity side (e.g., first entity server 504A). In an implementation, the ML module (e.g., 512) of the participating single-entity server monitors the input data according to step 606. An example of generating model output data using the entity's master feature model and worker models is shown in Figure 8, described below.

[0086] In step 607, each participating single entity server (e.g., the first entity server 504A) calculates the accuracy of the model (MA 2). See equation (2) below. In an embodiment, each participating single-entity server 504 begins calculating the accuracy of a model when the cached data associated with the model is greater than a user-specified data threshold. Various methods can be utilized to calculate the accuracy of a model, and implementations of the present invention are not intended to be limited by the examples described herein. In an implementation, the ML module (e.g., 512) of each participating single-entity server 504 performs step 607.

[0087] In step 608, each participating single-entity server (e.g., the first entity server 504A) updates or adjusts the weights of the worker model and the master feature model (initially applied in step 605) based on predetermined rules, as needed. In statistical modeling, regression analysis is a set of statistical procedures for estimating the relationship between a dependent variable and one or more independent variables. For regression predictive modeling, error metrics may be calculated. Metrics for regression include calculating an error score to summarize the predictive skill of the model. Three error metrics commonly used to evaluate and report the performance of a regression model include the mean squared error (MSE), root mean squared error (RMSE), and mean absolute error (MAE). In an implementation, if each participating single-entity server 504 determines that the cached data in its data cache (e.g., 511) is greater than a user-specified data threshold, it calculates the model accuracy or model metric (MAE) for the cached data. 2 ) and adjust the weights of the worker model using the following equation (2).

[0088] TIFF0007828702000004.tif16141

[0089] In the implementation, one of the following error metrics is used as the model metric (MA): 2) can be used as: Mean Squared Error (MSE), Root Mean Squared Error (RMSE), or Mean Absolute Error (MAE). In this example, the WW i represents the adjusted worker model weights of i (as new data comes to an entity, the worker model weights for this entity need to be adjusted), and WW j represents the other worker model weights (1 to j) not including i. Similarly, the master feature model of an entity utilizes the same strategy as the worker model. If equation (2) represents the adjustment of the master feature model weight, cached_WW can be converted to use cached_MW, the adjusted master model weight, and WW(j) then represents all worker models (1 to j, including i) since the master feature model weights are adjusted by all worker models. Thus, in an embodiment of the present invention, each participating single-entity server 504 adjusts the weights of the worker models and master feature models of its associated entities based on the calculated accuracy of the cached data. In an implementation, the ML module (e.g., 512) of each participating single-entity server (e.g., 504A) performs step 608. An illustrative example of the generation of new model data by associated entities for use in model training is depicted in FIG. 9, described below.

[0090] <Collaboration model> In step 609, the collaboration server 502 receives a query from a participating member of the subset group. For example, an employee of entity A of subset group 702B in FIG. 7 may utilize a graphical user interface (GUI) provided by the collaboration server 502 to submit a query to the collaboration server 502 that can be addressed by a federated machine learning model. In an implementation, the collaboration server 502 identifies a master feature model and a worker model associated with the participating member. A participating member of the dynamic virtual network of entities 700 may register with the collaboration server 502, and the collaboration server 502 may identify the participating member based on login information provided by the participating member to access the machine learning service of the collaboration server 502. For example, the member may belong to entity A of subset group 702B. In this example, the collaboration server 502 would obtain and utilize the master feature model and the worker model associated with subset group 702B to generate an output (a federated prediction) in response to the query. In an embodiment, the collaboration model module 517 performs step 609.

[0091] In step 610, the collaboration server 502 builds a collaboration model based on the master feature model and worker model of each entity in the participating member's subset group (e.g., subset group 702B in FIG. 7 ). In an implementation, the collaboration server 502 identifies and acquires all master feature models and worker models in the subset group. For example, in response to a query from an employee of entity A in subset group 702B, the collaboration server 502 acquires and uses the master feature models and worker models of entities A, C, and F. In an implementation, the collaboration server 502 may build the collaboration model before receiving a query from a participating member or in response to the query. Implementations of the present invention are not intended to be limited to the manner in which the collaboration server 502 forms and acquires the master feature models and worker models for the entities in the subset group. In an implementation, the model construction module 516 of the collaboration server 502 implements step 610 and stores the collaboration model in the collaboration model module 517. In an implementation, the federation model stored by the federation server 502 is usable by members of the dynamic virtual network of entities 700 .

[0092] In an embodiment, each participating single-entity server (e.g., first entity server 504A) manages a cache of master feature models and worker models. In an implementation, each participating single-entity server continuously or periodically calculates the accuracy of the active model (the model in use by the entity) based on the cached data by model metric, continuously builds new master feature models and worker models as needed based on changes to the respective entity's cached data blocks (e.g., data caches 511, 511', 511''), and caches a threshold T for use by federated server 502 in generating the federated model, per step 607. acc1 In an implementation, the master feature model and worker models with accuracy higher than a threshold T acc1If it is smaller, the collaboration server 502 utilizes (blends) the active model and the cached model in step 610. In an embodiment, the collaboration server 502 sorts the blended active and cached models by accuracy and selects the top S active models as a new active model list for use in the generated federated model in step 610. In an aspect of the present invention, each entity server 504 assigns weights to the selected active models based on the model's accuracy, adjusts the model's weight using adjustment formula (2), or reuses previously assigned weights for the models. An illustrative example of federating master feature models to generate a federated model is shown in FIG. 10, described below. An illustrative example of federating worker models to generate a federated model is shown in FIG. 11, described below.

[0093] In step 611, the collaboration server 502 generates a response (a collaboration prediction) utilizing the appropriate collaboration model identified in step 610 and outputs the response to the participating member in response to the query received in step 609. In an embodiment, the collaboration model module 517 of the collaboration server 502 performs step 611.

[0094] Unless otherwise noted, the steps of Figure 6 may be performed in a different order than depicted in Figure 6. Furthermore, it should be understood that the steps of Figure 6 performed by multiple entity servers 504 need not be performed simultaneously by each of the entity servers. Instead, each of the single entity servers 504 may perform the depicted steps independently of one another.

[0095] Figure 7 is a diagram illustrating the identification of entity groups according to steps 601 and 602 of Figure 6. The steps depicted in Figure 7 may be performed in the environment of Figure 5 and will be described with reference to elements depicted in Figure 5.

[0096] In the exemplary scenario of Figure 7, a collaboration server (e.g., collaboration server 502 of Figure 5) identifies a dynamic virtual network 700 of related entities including five subset groups 702. More specifically, collaboration server 502 obtains public data from a first entity server 504A, a second entity server 504B, and a third entity server 504C and generates respective relationship maps 704A, 704B, and 704C. As shown in Figure 7, each relationship map of a primary single-entity participant identifies other single-entity participants (e.g., neighbors 706), characteristics (e.g., features 707) of the other single-entity participants, and relationship parameters (e.g., relationships 708) that quantify the similarity between the primary single-entity participant's characteristics and the other single-entity participants' characteristics. For example, relationship map 704A shows that features F1, F2, and F3 of other entities B, C, and D result in the following: a relationship parameter between single entity A and single entity B of 0.992, a relationship parameter between single entity A and single entity C of 0.927, and a relationship parameter between single entity A and single entity D of 0.872.

[0097] 7, the relationship mapping results in five different 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), entity K, and entity G, based on information obtained from single entities A through V. In this example, single entities K and G do not have relationship parameters that meet the minimum threshold required to be grouped with another single-entity participant. That is, the characteristics of single entities K and G are not sufficiently similar to the characteristics of other single-entity participants for collaboration server 502 to group them with the other single-entity participants.

[0098] FIG. 8 illustrates the aggregation of worker models and master feature models by a single entity according to an embodiment of the present invention to generate and cache model outputs that can be monitored for changes in step 606 of FIG. 6 . In the example of FIG. 8 , a machine learning execution environment 800 of an entity (e.g., entity A) includes a first worker model WW1, a second worker model WW2, a third worker model WW3, and a master feature model MW. The outputs of worker models WW1, WW2, and WW3 are provided to the master feature model MW, as shown at 802, and can also be used as inputs to other worker models, as shown at 804. In an implementation, an entity (e.g., entity A) can generate predictions (e.g., responses to queries) based on its master feature model and worker models. In an implementation, a master response is predicted using an equation by applying the master feature model, and each worker response is predicted by applying a corresponding worker model. The results from the master feature model and worker models are aggregated by a single entity server (e.g., first entity server 504A) to obtain a final prediction using equation (3):

[0099] TIFF0007828702000005.tif7140

[0100] Here, WW i , the adjusted weights of the i worker models, MR is the output (response) of the master feature model, and WR i is the output (response) of the worker model, and S is the size of the partial feature subset, i = 1 to S. In one example, the initial MW = 0.5, the initial WW i =0.17.

[0101] 9 is a diagram illustrating a subset group data cache according to an embodiment of the present invention, which may be monitored according to step 606 of FIG. 9. In the example of FIG. 9, subset group 702B is depicted, which includes entities A, C, and F. As shown in FIG. 9, model outputs, shown as new blocks of data (e.g., Block 1, Block 2, Block 3), are generated for each of entities A, C, F, and F. C and F and may be shared among entities, for example as represented by 900. In an embodiment, each entity A, C and F The master feature model and worker models of each entity utilize private data inputs to generate model outputs. The new data is stored in at least one data cache 901, as shown at 902. The new block of data in the at least one data cache 901 is then cached, for example, by each entity A, as shown at 904. C and F may be utilized to train the master feature model and worker model for each entity by using the local master feature model and worker model trained by entities A, C, and F. As the local master feature model and worker model are trained by entities A, C, and F, the model output for the entities is improved (providing more accurate responses / predictions). Thus, the collaboration server 502 may train the master feature model and worker model for entities A, C, and F, as described in more detail below. C and F The updated / trained master feature model and worker models may be utilized to generate the federated model 908.

[0102] FIG. 10 is a diagram illustrating the generation of a federation model 1000 according to step 610 of FIG. 6. In the example of FIG. 10, the federation server 502 generates a federation model 1000 for a subset group 702B of the dynamic virtual network of entities 700 of FIG. 7, which includes entities A, C, and F. FIG. 10 depicts aggregate master feature model and worker model outputs e1, e2, and e3 generated by entities A, C, and F, which may be shared among the entities for model training purposes. Each master feature model (e.g., Master Models 1-3) is assigned a weight W i to the parameters to provide a weighted output, shown at 1002. In an implementation, the collaboration server 502 combines all master feature models of a subset group (e.g., 702B) using a parallel computation weighting equation. The equation may be stochastic gradient descent (SGD) or parameter averaging (shown at 1004 in FIG. 10 ), depending on the performance cost and computing metric. In an implementation, the collaboration server 502 generates the collaboration model utilizing the following parameter averaging equation (4):

[0103] TIFF0007828702000006.tif11162

[0104] FIG. 11 illustrates the use of collaborative worker models according to step 610 of FIG. 6. In the machine learning collaborative model 1000, worker models are constructed with partial features. In the example of FIG. 11, worker models FWW1, FWW2, and FWW3 of each entity (e.g., A, F, C) are utilized to generate respective predictor sets 1-3. FIG. 11 depicts worker model outputs e1, e2, and e3 generated by each entity's worker (e.g., workers A-C), which may be shared among the entities for model training purposes. In an embodiment, the collaborative server 502 obtains a collaborative prediction using the following equation (5):

[0105] TIFF0007828702000007.tif24160

[0106] Here, FMW is the federation model, MW is the weight for the master model, MR is the master feature model output, FWW is the combined / federated worker model, WW is the initial weight for the master feature model, and WR is the worker model output.

[0107] Figure 12 is a diagram illustrating a workflow in a federated system for machine learning models according to an embodiment of the present invention. The steps of Figure 6 are illustrated in Figure 12 and may be performed in the environment 500 of Figure 5. It should be understood that multiple iterations of the workflow depicted in Figure 12 result in continuous training of the machine learning models of the present invention.

[0108] At the start of an iteration (1200), a first entity server 504A of an entity (e.g., entity A) collects 1202 public or shared information 1203 about other participating entities (e.g., C and F of subset group 702B). The first entity server 504A may collect 1202 the information according to step 600 of FIG. 6. The first entity server 504A may store information about the entity's features in a database as a feature collection 1204. As new information is collected 1202, the first entity server 504A may identify new features 1205 to be added to new master feature models and worker models.

[0109] Still referring to FIG. 12 , at 1206, the first entity server 504A builds one master feature model 1207 incorporating all features of interest identified by the first entity server 504A. The federation server 502 can combine (federate) features from the related master feature models 1207 using parameter averaging integration 1208 to obtain a federated master feature model for use in federation model 1209. Step 1206 may be performed according to step 604 of FIG. 6 . The master feature model 1207 for an entity may be retrained by that entity (e.g., the first entity server 504A), as shown at 1210. In an implementation, the entity selects a subset group of features for partial computation and begins iterative regression. In an embodiment, the entity leverages previous features in the master feature model 1207 but collects more detailed information (e.g., private or confidential information) at the entity's location. The additional information may include, for example, values ​​of key parameters, business configuration information (e.g., financial, cloud usage, etc.), or information regarding characteristics of the input data, or a combination thereof. In an embodiment, an entity (e.g., the first entity server 504A) builds a regression model for the relationship between features and targets. In an implementation, an entity (e.g., entity A) may utilize the following equation (6):

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

[0111] At 1211 of FIG. 12, the first entity server 504A builds multiple worker models 1212. Each worker model is built for a feature subset 1213 that includes a subset of all features of the master feature model 1207. In an implementation, 1211 may be performed according to step 603 of FIG. 6. In the example of FIG. 12, worker models are built for features FM1, FM2, and FM3, where S is the size of the partial feature subset and S=3. In an embodiment, the worker models are built for a key feature subset 1214, where key features are fixed features that are always utilized in modeling (as opposed to optional features that may be modeled). In an embodiment, a collaboration server (e.g., 502 of FIG. 5) combines features from the worker models 1212 using parameter averaging integration 1215 (i.e., collaborating worker models from different entities) for use in the collaboration model 1209. The first entity server 504A may optimize the worker model by adjusting the weights of the worker model, as depicted at 1216, according to step 608 of FIG.

[0112] At 1217, the first entity server 504A assigns initial weights to the master feature model and the worker model. Step 1217 may be performed according to step 605 of FIG. 6. In the example of FIG. 12, the master feature model is assigned an initial weight MW, and the worker model has an initial weight WWn. In this example, MW=e, where e is greater than 0 and less than 1, and WWn=(1-e) / S. For example, when S=3 and e=0.5, MW=0.5, WWn=(1-e) / S. n =0.17.

[0113] At 1218, the first entity server 504A adjusts the model weights, if necessary. Step 1218 may be performed according to step 608 of Figure 6. In an 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 master feature model and worker models and adjusts the model weights according to the accuracy.

[0114] Advantageously, embodiments of the present invention build a dynamic virtual network of related entities to share their individual machine learning models. In implementations, at the feature level, master feature models and worker models are built with dynamic feature weight relationships. In embodiments, at the model level, the federated distributed system continuously learns based on iterative computations from individual sensitive data models.

[0115] In embodiments, a service provider may offer to perform the processes described herein. In this case, the service provider may create, maintain, deploy, support, etc., a computer infrastructure that performs the process steps of the present invention for one or more customers. These customers may be, for example, any business that uses technology. In return, the service provider may receive payments from the customers based on subscription or fee agreements, or both, or the service provider may receive payments from the sale of advertising content to one or more third parties, or both.

[0116] In yet an additional embodiment, the present invention provides a computer-implemented method over a network. In this case, a computer infrastructure, such as computer system / server 12 (FIG. 1), may be provided, and one or more systems for performing the processes of the present invention may be obtained (e.g., created, purchased, used, modified, etc.) and deployed to the computer infrastructure. To this extent, deploying the system may include one or more of: (1) installing program code from a computer-readable medium onto a computing device, such as computer system / server 12 (shown in FIG. 1); (2) adding one or more computing devices to the computer infrastructure; or (3) incorporating and / or modifying one or more existing systems of the computer infrastructure so that the computer infrastructure is capable of performing the processes of the present invention.

[0117] The description of various embodiments of the present invention is presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. It will be apparent to those skilled in the art that many modifications and variations are possible without departing from the scope of the described embodiments. The terms used herein have been selected to best explain the principles of the embodiments, practical applications or technical improvements to technology found in the market, or to enable those skilled in the art to understand the embodiments described herein.

Claims

1. monitoring, by a computing device, cached data of entities in a group of networked entities for changes in the data, the cached data including model output data from worker models and master feature models of the entities, the worker models and the master feature models including 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; providing, by the computing device, the updated worker model and the updated master feature model of the entity to a remote federation server for use in a federation model that incorporates 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; A method comprising:

2. constructing, by the computing device, the worker models, each of the worker models including a subset of the set of features associated with the entity; constructing, by the computing device, the master feature model, the master feature model including all features in the set of features associated with the entity; The method of claim 1 further comprising:

3. The method of claim 1 , further comprising generating, by the computing device, a model output utilizing a parameter-averaging combination of the master feature model and the worker model of the entity.

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

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

6. sending, by the computing device, queries from participating members of the group of networked entities to the coordination server; receiving, by the computing device, a response to the query from the collaboration server, the response being based on an output of the collaboration model; The method of claim 1 further comprising:

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

8. A computer program, the computer program being executable by a computing device, the computing device comprising: monitoring cached data of entities in a group of networked entities for changes in the data, the cached data including model output data from worker models and master feature models of the entities, the worker models and the master feature models including machine learning models; iteratively updating 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; providing the updated master feature model and the updated worker model of the entity to a remote federation server for use in a federation model that incorporates 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 group of networked entities; A computer program that executes

9. The computer program is further executable by the computing device and causes the computing device to: generating a vector map representing relationships between entities in the group of networked entities based on characteristics of each entity; identifying a group of related entities based on the vector map, the group of networked entities comprising the group of related entities, each entity in the group of related entities being associated with a set of features; 9. The computer program product of claim 8, which causes the computer to execute the following:

10. 10. The computer program of claim 9, wherein the computer program is further executable by the computing device to cause the computing device to identify the characteristics of the plurality of remote entities based solely on public information of the plurality of remote entities.

11. The computer program is further executable by the computing device and causes the computing device to: constructing the worker models, each of the worker models including a subset of the set of features associated with the entity; constructing the master feature model, the master feature model including all features in the set of features associated with the entity; 9. The computer program product of claim 8, which causes the computer to execute the following:

12. 9. The computer program of claim 8, wherein the computer program is further executable by the computing device to cause the computing device to generate a model output based on the worker model and the master feature model of the entity.

13. 9. The computer program of claim 8, wherein the computer program is further executable by the computing device to cause the computing device to assign initial parameter weights to the worker model and the master feature model of the entity.

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

15. The computer program is further executable by the computing device and causes the computing device to: sending queries from participating members of the group of networked entities to the coordination server; receiving a response to the query from the collaboration server, the response being based on an output of the collaboration model; 9. The computer program product of claim 8, which causes the computer to execute the following:

16. 9. The computer program product of claim 8, wherein the federation model is generated using a parameter averaging integration of the updated master feature model and the updated worker model of the entity with the other updated master feature models and the other updated worker models of the other entities in the group of networked entities.

17. a processor, a computer-readable memory, one or more computer-readable storage media, and program instructions collectively stored on the one or more computer-readable storage media, the program instructions being executable by a collaboration server, the collaboration server being configured to: receiving inquiries from participating members of the group of networked entities; generating a federation model based on the master feature model and the worker model of each entity in the group of networked entities; generating a response to the query based on an output of the federation model; sending the response to the query to the participating member; each of the master feature models includes all features of each entity in the group of networked entities; each of the worker models includes a subset of all of the characteristics of a respective entity in the group of networked entities; the master feature model and the worker model are iteratively updated by the respective entities based on private data that is not accessible by the collaboration server; The iterative updating is based on the respective entities monitoring cached data of entities in the group of networked entities for changes in the data, the cached data including model output data from the worker models and the master feature models of the entities, the worker models and the master feature models including machine learning models. system.

18. The system of claim 17 , wherein generating the federation model comprises performing a parameter averaging integration of the master feature model and the worker model of the respective entity.

19. The system of claim 17 , wherein the coordination server includes software provided as a service in a cloud environment.

20. The program instructions are further executable by the coordinating server, and cause the coordinating server to: generating a vector map representing relationships between a plurality of remote entities based on the public information; identifying the group of networked entities from a plurality of remote entities based on the vector map; The system of claim 17,

Images