Distributed Nonnegative Matrix Factorization for Big Data

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing nonnegative matrix factorization and completion (NMFC) methods are not accurate and scalable for large problems due to their non-convex formulation and underlying inverse problems, which makes them inefficient for handling large-scale data matrices.

Innovation Solution

The system employs an efficient greedy and distributed process for NMFC (GD-NMFC) by partitioning a large-scale data matrix into smaller submatrices, using rank-one ADMM for parallel optimization, and concatenating solutions to form low-rank matrix factors, eliminating the matrix inverse problem and enabling faster convergence.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If existing NMFC methods are used to handle large-scale data matrices, then the problem formulation is straightforward, but the computational complexity increases and scalability deteriorates

Engineering Contradiction:
Improveprocessing speedVSAvoidcomputational complexity
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent divides the large-scale data matrix into multiple smaller submatrices that can be processed in parallel across different computing nodes. This segmentation approach allows the system to handle large problems by breaking them into manageable chunks, improving both processing speed and scalability while reducing the computational burden on individual nodes

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent introduces a distributed computing dimension by implementing NMFC across multiple processing nodes rather than a single node. This dimensional transformation from centralized to distributed processing enables the system to scale horizontally, handling larger data matrices efficiently by leveraging parallel computation resources

Inventive Principle:
Principle #17Another dimension (Dimensionality change)

2Measurement precision

If existing NMFC methods are used for large problems, then the non-convex formulation is maintained, but accuracy and scalability worsen

Engineering Contradiction:
Improvesolution accuracyVSAvoidscalability
Core Design Contradiction:
Measurement precisionVSAdaptability or versatility

Solution Approach 1:

By segmenting the large-scale matrix factorization problem into smaller subproblems that can be solved independently in parallel, the system maintains solution accuracy while achieving scalability. Each submatrix factorization contributes to the overall solution, allowing accurate computation to be distributed across multiple nodes without sacrificing precision

Inventive Principle:
Principle #1Segmentation

3Productivity

If matrix inverse problems are solved in existing NMFC methods, then the factorization is achieved, but computational efficiency deteriorates due to the inverse problem

Engineering Contradiction:
Improveconvergence speedVSAvoidalgorithmic complexity
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent extracts and eliminates the computationally expensive matrix inverse operations from the NMFC algorithm by reformulating the problem to avoid explicit inversion. This extraction of the problematic inverse computation step replaces it with more efficient operations that maintain factorization accuracy while dramatically improving convergence speed and reducing algorithmic complexity

Inventive Principle:
Principle #2Taking out (Extraction)

Data Source

PatentUS10304008B2Fast distributed nonnegative matrix factorization and completion for big data analytics
Publication Date: 2019.05.28 NEC CORP
  • US10304008B2 patent drawing
  • US10304008B2 patent drawing
  • US10304008B2 patent drawing

AI summary

Systems and methods are disclosed for operating a machine, by receiving training data from one or more sensors; training a machine learning module with the training data by: partitioning a data matrix into smaller submatrices to process in parallel and optimized for each processing node; for each submatrix, performing a greedy search for rank-one solutions; using alternating direction method of multipliers (ADMM) to ensure consistency over different data blocks; and controlling one or more actuators using live data and the learned module during operation.