DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Response to Amendment/Arguments
1. Applicant’s arguments to the rejection under 35 U.S.C. 101 filed on January 2, 2026 have been fully considered but are not persuasive. Applicant asserts that the claims are not directed to an abstract idea because they recite training and implementing a machine learning model to determine an optimal batch size.
However, Applicant’s arguments are not persuasive. The claims recite analyzing data (e.g., dataset size and available resources), evaluating performance, and determining an optimal batch size based on these evaluations. Such steps constitute observations, evaluations, and judgements, which fall within the “mental processes” grouping of abstract ideas. As set forth in MPEP 2106.04(a)(2)(III), The courts consider a mental process (thinking) that "can be performed in the human mind, or by a human using a pen and paper" to be an abstract idea. CyberSource Corp. v. Retail Decisions, Inc., 654 F.3d 1366, 1372, 99 USPQ2d 1690, 1695 (Fed. Cir. 2011). Further, "methods which can be performed mentally, or which are the equivalent of human mental work, are unpatentable abstract ideas the ‘basic tools of scientific and technological work’ that are open to all.’" 654 F.3d at 1371, 99 USPQ2d at 1694 (citing Gottschalk v. Benson, 409 U.S. 63, 175 USPQ 673 (1972)).
Further, the fact that the claims recite performing these steps using a machine learning model or a computer does not render the claims non-abstract. The courts have made clear that claims may still be directed to mental processes even when performed on a computer. See MPEP 2106.04(a)(2)(III)(C).
Accordingly, the amended claims continue to be directed to a judicial exception without significantly more, and the rejection under 35 U.S.C. 101 is maintained.
2. Applicant’s arguments in regards to the rejection under 35 U.S.C. 103 filed on January 2, 2026 are not persuasive. Applicant's arguments fail to comply with 37 CFR 1.111(b) because they amount to a general allegation that the claims define a patentable invention without specifically pointing out how the language of the claims patentably distinguishes them from the references.
Applicant merely reproduces portions of the claim language and asserts, in a conclusory manner, that the cited references, individually or in combination, fail to disclose or suggest the recited limitations. However, Applicant does not identify any specific deficiency in the Examiner’s findings, does not address the specific teachings relied upon in the applied references, and does not explain how any particular limitation is not taught or suggested by the cited art.
Further, Applicant does not address the Examiner’s articulated reasoning for combining the references nor does Applicant present arguments regarding any specific claim limitation, motivation to combine, or reasonable expectation of success. Applicant’s arguments amount to general disagreement with the rejection without substantive analysis.
Accordingly, in the absence of specific arguments identifying error in the rejection, the rejection of claims 1, 3-8, 10-13, 15, and 17-20 under 35 U.S.C. 103 are maintained.
Claim Rejections - 35 USC § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claims 1, 3-6, 8, 10-13, 15, 17-20 are rejected under 35 U.S.C. 101 because the claimed invention is directed to a judicial exception (i.e., a law of nature, a natural phenomenon, or an abstract idea) without significantly more.
101 Subject Matter Eligibility Analysis
Step 1: Claims 1, 3-6, 8, 10-13, 15, 17-20 are within the four statutory categories (a process, machine, manufacture or composition of matter).
Step 2A Prong One, Step 2A Prong Two, and Step 2B Analysis:
Step 2A Prong One asks if the claim recites a judicial exception (abstract idea, law of nature, or natural phenomenon). If the claim recites a judicial exception, analysis proceeds to Step 2A Prong Two, which asks if the claim recites additional elements that integrate the abstract idea into a practical application. If the claim does not integrate the judicial exception, analysis proceeds to Step 2B, which asks if the claim amounts to significantly more than the judicial exception. If the claim does not amount to significantly more than the judicial exception, the claim is not eligible subject matter under 35 U.S.C. 101.
None of the claims represent an improvement to technology.
Claims 1, and 3-6 are directed to a method consisting of a series of steps, meaning that it is directed to the statutory category of process. Claims 8, 10-13, 15, and 17-20 are directed to processors which are machines.
Regarding claim 1, the following claim elements are abstract ideas:
determining…a size of a subsequent data set, the size of the subsequent data set including a first quantity of database records (This is an abstract idea of a “mental process.” The limitation recites a mathematical evaluation of dataset size. A person could determine the size of a dataset by counting or estimating the number of records, either mentally or with the aid of pen and paper. Such evaluation of quantity constitutes a mathematical calculation that can be performed in the human mind. Accordingly, this limitation falls within the mental process grouping of abstract ideas.)
ascertaining…available resources, the available resources including one or more quantity of servers, central processing unit resources, amount of memory, quantity of threads, or quantity of database connections (This is an abstract idea of a “mental process.” It amounts to observing and identifying which resources are available – e.g., reviewing a list or display of machines/CPUs/GPUs, noting current usage, tallying free units, and deciding what is available – activities that can be performed in the human mind. Because it can be carried out mentally, it falls within the mental process grouping of abstract ideas.);
determining…an optimal batch size for the subsequent data set based, at least in part, on the available resources and the size of the subsequent data set (This is an abstract idea of a “mental process.” It entails using observation and reasoning to evaluate constraints (e.g., observed memory/compute limits and data size) and select a batch size – an activity that can be performed in the human mind or with basic tools using the mind (e.g., pen-and-paper arithmetic or simple calculator/spreadsheet applying heuristics like “largest batch that fits with 20% headroom”).
wherein determining the optimal batch size comprises performing gradient descent (This is an abstract idea of a “mathematical concept.” Gradient descent is a mathematical algorithm involving iterative calculations based on gradients to minimize a function. Such calculations represent mathematical relationships and operations that can be performed in the human mind or with basic mathematical tools such as a calculator.),
The following claim elements are additional elements which, taken alone or in combination with the other elements, do not integrate the judicial exception into a practical application nor amount to significantly more than the judicial exception:
training a machine learning model using historical data, the machine learning model having a plurality of weights, each weight corresponding to one of a plurality of variables, the historical data including a plurality of training data sets (The step of “training” a model is merely an instruction to apply the abstract idea and does provide a meaningful limitation. See MPEP 2106.05(f).)
each training data set including resource characteristics of resources consumed during a previously executed parallel batch process, a size of a data set processed during the previously executed parallel batch process, a batch size of the previously executed parallel batch process, and a processing time associated with the previously executed parallel batch process (This limitation is an insignificant extra-solution activity because it merely describes the contents/fields of the data to be collected and stored. Specifying data attributes is mere data gathering/organization, which is well-understood, routine, and conventional and does not integrate the judicial exception in a practical application. See MPEP 2106.05(g) and 2106.05(d)(II)(iv).);
processing the subsequent data set by performing parallel processing using the available resources according to the optimal batch size (Mere instructions to apply the abstract idea on generic computers; routine parallel execution/resource scheduling is well-understood, routine, and conventional and constitutes an insignificant extra-solution activity. See MPEP 2106.05(f), 2106.05(d)(II), and 2106.05(g).).
by the at least one processor (This limitation constitutes mere instructions to apply the abstract idea and insignificant extra-solution activity. See MPEP 2106.05(f) and 2106.05(g).)
the optimal batch size for the subsequent data set including a second quantity of database records (This limitation amounts to insignificant extra solution activity.);
Regarding claim 3, the rejection of claim 1 is incorporated herein. Further, claim 3 recites the following abstract ideas:
wherein determining the optimal batch size comprises applying an optimization algorithm to the machine learning algorithm such that a minimum processing time is predicted (This is an abstract idea of a “mental process.” It entails using observation and reasoning to evaluate constraints and apply a rule/heuristic to select a batch size expected to minimize processing time – an activity performable in the human mind or with basic tools using the mind.).
The following claim elements are additional elements which, taken alone or in combination with the other elements, do not integrate the judicial exception into a practical application nor amount to significantly more than the judicial exception:
the machine learning algorithm configured to predict a minimum processing time (Configuring the machine learning algorithm is merely an instruction to apply the abstract idea and does provide a meaningful limitation. See MPEP 2106.05(f).),
Regarding claim 4, the rejection of claim 1 is incorporated herein. Further, claim 4 recites the following abstract ideas:
wherein determining the optimal batch size comprises applying the machine learning model to the available resources such that a total predicted processing time is minimized (This is an abstract idea of a “mental process.” It entails using observation and reasoning to evaluate constraints and apply rule/heuristic to select a batch size expected to minimize processing time – an activity performable in the human mind or with basic tools using the mind.).
Regarding claim 5, the rejection of claim 1 is incorporated herein. Further, claim 5 recites the following additional elements, which taken alone or in combination with other elements, do not integrate the judicial exception into a practical application nor amount to significantly more than the judicial exception:
the plurality of variables including a first variable corresponding to a quantity of servers and a second variable corresponding to a batch size (This limitation amounts to adding insignificant extra-solution activity to the judicial exception, as discussed in MPEP 2106.05(g).).
Regarding claim 6, the rejection of claim 1 is incorporated herein. Further, claim 6 recites the following additional elements, which taken alone or in combination with other elements, do not integrate the judicial exception into a practical application nor amount to significantly more than the judicial exception:
the plurality of variables including a first variable corresponding to a quantity of threads and a second variable corresponding to a quantity of database connections (This limitation amounts to adding insignificant extra-solution activity to the judicial exception, as discussed in MPEP 2106.05(g).).
Regarding claim 8, the following claim elements are abstract ideas:
determining…a size of a subsequent data set, the size of the subsequent data set including a first quantity of database records (This is an abstract idea of a “mental process.” The limitation recites a mathematical evaluation of dataset size. A person could determine the size of a dataset by counting or estimating the number of records, either mentally or with the aid of pen and paper. Such evaluation of quantity constitutes a mathematical calculation that can be performed in the human mind. Accordingly, this limitation falls within the mental process grouping of abstract ideas.)
ascertaining available resources, the available resources including one or more of a quantity of servers, central processing unit resources, amount of memory, quantity of threads, or quantity of database connections; (This is an abstract idea of a “mental process.” It amounts to observing and identifying which resources are available – e.g., reviewing a list or display of machines/CPUs/GPUs, noting current usage, tallying free units, and deciding what is available – activities that can be performed in the human mind. Because it can be carried out mentally, it falls within the mental process grouping of abstract ideas.);
determining, using the machine learning model, an optimal batch size for the subsequent data set based, at least in part, on the available resources and the size of the subsequent data set (This is an abstract idea of a “mental process.” It entails using observation and reasoning to evaluate constraints (e.g., observed memory/compute limits and data size) and select a batch size – an activity that can be performed in the human mind or with basic tools using the mind (e.g., pen-and-paper arithmetic or simple calculator/spreadsheet applying heuristics like “largest batch that fits with 20% headroom”).
wherein determining the optimal batch size comprises performing gradient descent (This is an abstract idea of a “mathematical concept.” Gradient descent is a mathematical algorithm involving iterative calculations based on gradients to minimize a function. Such calculations represent mathematical relationships and operations that can be performed in the human mind or with basic mathematical tools such as a calculator.),
The following claim elements are additional elements which, taken alone or in combination with the other elements, do not integrate the judicial exception into a practical application nor amount to significantly more than the judicial exception:
a database system (This is a high-level recitation of generic computer components for performing the abstract idea. See MPEP 2106.05.);
a server system (This is a high-level recitation of generic computer components for performing the abstract idea. See MPEP 2106.05.),
by at least one processor (This limitation constitutes mere instructions to apply the abstract idea and insignificant extra-solution activity. See MPEP 2106.05(f) and 2106.05(g).)
training a machine learning model using historical data, the machine learning model having a plurality of weights, each weight corresponding to one of a plurality of variables, the historical data including a plurality of training data sets (The step of “training” a model is merely an instruction to apply the abstract idea and does provide a meaningful limitation. See MPEP 2106.05(f).)
each training data set including resource characteristics of resources consumed during a previously executed parallel batch process, a size of a data set processed during the previously executed parallel batch process, a batch size of the previously executed parallel batch process, and a processing time associated with the previously executed parallel batch process (This limitation is an insignificant extra-solution activity because it merely describes the contents/fields of the data to be collected and stored. Specifying data attributes is mere data gathering/organization, which is well-understood, routine, and conventional and does not integrate the judicial exception in a practical application. See MPEP 2106.05(g) and 2106.05(d)(II)(iv).);
processing the subsequent data set by performing parallel processing using the available resources according to the optimal batch size (Mere instructions to apply the abstract idea on generic computers; routine parallel execution/resource scheduling is well-understood, routine, and conventional and constitutes an insignificant extra-solution activity. See MPEP 2106.05(f), 2106.05(d)(II), and 2106.05(g).).
the optimal batch size for the subsequent data set including a second quantity of database records (This limitation amounts to insignificant extra solution activity.);
Regarding claim 10, the rejection of claim 8 is incorporated herein. The claim recites similar limitations corresponding to claim 3. Therefore, the same subject matter analysis that was utilized for claim 3, as described above, is equally applicable to claim 10.
Therefore, claim 10 is ineligible.
Regarding claim 11, the rejection of claim 8 is incorporated herein. The claim recites similar limitations corresponding to claim 4. Therefore, the same subject matter analysis that was utilized for claim 4, as described above, is equally applicable to claim 11.
Therefore, claim 11 is ineligible.
Regarding claim 12, the rejection of claim 8 is incorporated herein. The claim recites similar limitations corresponding to claim 5. Therefore, the same subject matter analysis that was utilized for claim 5, as described above, is equally applicable to claim 12.
Therefore, claim 12 is ineligible.
Regarding claim 13, the rejection of claim 8 is incorporated herein. The claim recites similar limitations corresponding to claim 6. Therefore, the same subject matter analysis that was utilized for claim 6, as described above, is equally applicable to claim 13.
Therefore, claim 13 is ineligible.
Regarding claim 15, the following claim elements are abstract ideas:
determining…a size of a subsequent data set, the size of the subsequent data set including a first quantity of database records (This is an abstract idea of a “mental process.” The limitation recites a mathematical evaluation of dataset size. A person could determine the size of a dataset by counting or estimating the number of records, either mentally or with the aid of pen and paper. Such evaluation of quantity constitutes a mathematical calculation that can be performed in the human mind. Accordingly, this limitation falls within the mental process grouping of abstract ideas.)
ascertaining…available resources, the available resources including one or more of a quantity of servers, central processing unit resources, amount of memory, quantity of threads, or quantity of database connections; (This is an abstract idea of a “mental process.” It amounts to observing and identifying which resources are available – e.g., reviewing a list or display of machines/CPUs/GPUs, noting current usage, tallying free units, and deciding what is available – activities that can be performed in the human mind. Because it can be carried out mentally, it falls within the mental process grouping of abstract ideas.);
determining, using the machine learning model, an optimal batch size for the subsequent data set based, at least in part, on the available resources and the size of the subsequent data set (This is an abstract idea of a “mental process.” It entails using observation and reasoning to evaluate constraints (e.g., observed memory/compute limits and data size) and select a batch size – an activity that can be performed in the human mind or with basic tools using the mind (e.g., pen-and-paper arithmetic or simple calculator/spreadsheet applying heuristics like “largest batch that fits with 20% headroom”).
wherein determining the optimal batch size comprises performing gradient descent (This is an abstract idea of a “mathematical concept.” Gradient descent is a mathematical algorithm involving iterative calculations based on gradients to minimize a function. Such calculations represent mathematical relationships and operations that can be performed in the human mind or with basic mathematical tools such as a calculator.),
The following claim elements are additional elements which, taken alone or in combination with the other elements, do not integrate the judicial exception into a practical application nor amount to significantly more than the judicial exception:
non-transitory computer-readable storage medium (This is a high-level recitation of generic computer components for performing the abstract idea. See MPEP 2106.05.)
computer-readable program code (This is a high-level recitation of generic computer components for performing the abstract idea. See MPEP 2106.05.)
by at least one processor (This limitation constitutes mere instructions to apply the abstract idea and insignificant extra-solution activity. See MPEP 2106.05(f) and 2106.05(g).)
training a machine learning model using historical data, the machine learning model having a plurality of weights, each weight corresponding to one of a plurality of variables, the historical data including a plurality of training data sets (The step of “training” a model is merely an instruction to apply the abstract idea and does provide a meaningful limitation. See MPEP 2106.05(f).)
each training data set including resource characteristics of resources consumed during a previously executed parallel batch process, a size of a data set processed during the previously executed parallel batch process, a batch size of the previously executed parallel batch process, and a processing time associated with the previously executed parallel batch process (This limitation is an insignificant extra-solution activity because it merely describes the contents/fields of the data to be collected and stored. Specifying data attributes is mere data gathering/organization, which is well-understood, routine, and conventional and does not integrate the judicial exception in a practical application. See MPEP 2106.05(g) and 2106.05(d)(II)(iv).);
processing the subsequent data set by performing parallel processing using the available resources according to the optimal batch size (Mere instructions to apply the abstract idea on generic computers; routine parallel execution/resource scheduling is well-understood, routine, and conventional and constitutes an insignificant extra-solution activity. See MPEP 2106.05(f), 2106.05(d)(II), and 2106.05(g).).
the optimal batch size for the subsequent data set including a second quantity of database records (This limitation amounts to insignificant extra solution activity.);
Regarding claim 17, the rejection of claim 15 is incorporated herein. The claim recites similar limitations corresponding to claim 3. Therefore, the same subject matter analysis that was utilized for claim 3, as described above, is equally applicable to claim 17.
Therefore, claim 17 is ineligible.
Regarding claim 18, the rejection of claim 15 is incorporated herein. The claim recites similar limitations corresponding to claim 4. Therefore, the same subject matter analysis that was utilized for claim 4, as described above, is equally applicable to claim 18.
Therefore, claim 18 is ineligible.
Regarding claim 19, the rejection of claim 15 is incorporated herein. The claim recites similar limitations corresponding to claim 5. Therefore, the same subject matter analysis that was utilized for claim 5, as described above, is equally applicable to claim 19.
Therefore, claim 19 is ineligible.
Regarding claim 20, the rejection of claim 15 is incorporated herein. The claim recites similar limitations corresponding to claim 6. Therefore, the same subject matter analysis that was utilized for claim 6, as described above, is equally applicable to claim 20.
Therefore, claim 20 is ineligible.
Claim Rejections - 35 USC § 103
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1, 3-6, 8, 10-13, 15, and 17-20 are rejected under the 35 U.S.C. 103 as being unpatentable over Laberge et al., (NPL: “Scheduling Optimization of Parallel Linear Algebra Algorithms Using Supervised Learning” (Published: 2019)) in view of Venkataraman et al., (NPL: “Ernest: Efficient Performance Prediction for Large-Scale Advanced Analytics” (Published: 2016)).
Regarding claim 1, Laberge teaches the limitation:
A method, comprising: training, by at least one processor, a machine learning model using historical data, the machine learning model having a plurality of weights, each weight corresponding to one of a plurality of variables (Laberge, Abstract “In the realm of Asynchronous Many Task runtime systems, a key aspect of the scheduling problem is predicting the proper chunk-size, where the chunk-size is defined as the number of iterations of a for-loop assigned to a thread as one task. In this paper, we study the applications of supervised learning models to predict the chunk-size which yields maximum performance on multiple parallel linear algebra operations using the HPX backend of Blaze’s linear algebra library…We compare the use of logistic regression, neural networks and decision trees with a newly developed decision tree based model in order to predict the optimal value for chunk-size.” -models with parameters/weights over input features. Section 4.3 - “Once the approximation of the best block-size is computed for any
o
t
and
a
r
, we can redefine the abstract feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
.” - variables to determine chunk/batch size.) , the historical data including a plurality of training data sets (Abstract, “we generate our training and tests sets by measuring performance of the application with different chunk-sizes for multiple linear algebra operations” – historical data, prior runs), each training data set including resource characteristics of resources consumed during a previously executed parallel batch process (section 3.3, the paper describes the “
a
r
” (architecture), and
N
t
h
r
(
number of threads) as the resources available to determine chunk size (batch size) ), a size of a data set processed during the previously executed parallel batch process, a batch size of the previously executed parallel batch process (Abstract, “we generate our training and tests sets by measuring performance of the application with different chunk-sizes” and Section 4.3, “Once the approximation of the best block-size is computed for any
o
t
and
a
r
, we can redefine the abstract feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
. The best chunk-size can be calculated by solving the problem:… “ (equation 4) – the training/test sets are built from previous executions, and each example’s features include
m
s
(problem/data size) – i.e., the size of the dataset processed in these prior runs. Because each prior run in the training data stores performance for each chunk/batch size cs, the batch size used in previously executed processes is explicitly captured.), and a processing time associated with the previously executed parallel batch process ;
determining, by at least one processor, a size of a subsequent data set, the size of the subsequent data set including a first quantity of database records (Laberge, section 4.5 “Run-time features like
m
s
(matrix size/data size)… can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
function and Blaze’s
m
a
t
r
i
x
.
c
o
l
s
member function for Matrix/Vector classes” – under the broadest reasonable interpretation, a “first quantity of database records” corresponds to a size of a dataset, i.e., amount of data being processed. Laberge’s matrix size (ms), which represents the size of the data being processed, therefore corresponds to the claimed first quantity of database records.); ascertaining, by at least one processor, available resources, the size of the subsequent data set including a first quantity of database records (section 4.5, “Run-time features like
m
s
and
N
t
h
r
(resources available) can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
”- Laberge’s N_thr represents the number of threads available for execution, which corresponds to the claimed quantity of threads as one of the available resources.);
and processing, by the at least one processor, the subsequent data set by performing parallel processing using the available resources according to the optimal batch size (Section 3.2 – Parallelization Framework, “The elements of an expression are only evaluated when the assignment operator is called, i.e.
C
=
E
x
p
r
e
s
s
i
o
n
T
e
m
p
l
a
t
e
(
A
,
B
)
. During an assignment, the elements of the expression template are evaluated and the results are stored in
C
. This step can be parallelized since each component of
C
is independently computed. Figure 1 shows how work is distributed among threads and introduces the two critical parameters involved: block-size and chunk-size. In this work, we demonstrate the use of machine learning to simplify the task of selecting the chunk sizes, given a specified block-size.” and Abstract, “predicting the proper chunk-size, where the chunk-size is defined as the number of iterations of a for-loop assigned to a thread as one task.”)
However, Laberge does not teach, but Laberge in view of Venkataraman teaches the following limitations:
and a processing time associated with the previously executed parallel batch process (Venkataraman, section 3.1, “To build our model we add terms related to the computation
and communication patterns…The terms we add to our linear model are (a) a fixed cost
term which represents the amount of time spent in serial computation (b) the interaction between the scale and the inverse of the number of machines; this is to capture the
parallel computation time… (c) a log(machines) term to model communication patterns… (d) a linear term O(machines) which captures the all-to-one communication pattern and fixed overheads…Thus the overall model we are fitting tries to learn values for…in the formula” - describes the features used in the linear model where the dependent variable is the total processing time. The subsequent formula shown in the paper explicitly models this total time.);
wherein determining the optimal batch size comprises performing gradient descent, the optimal batch size for the subsequent data set including a second quantity of database records (Venkataraman, [page 364, Introduction] “a mini-batch gradient descent algorithm used for linear regression. Laberge, [section 4.5] “Run-time features like
m
s
(matrix size/data size)… can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
( ) function and Blaze’s
m
a
t
r
i
x
.
c
o
l
s
member function for Matrix/Vector classes” – Venkataraman teaches performing gradient descent (e.g., mini-batch gradient descent) in a machine-learning context. Under BRI, “comprising performing gradient descent” requires only gradient descent be performed as part of the process. Further, as discussed above, Laberge’s data size (ms) corresponds to a quantity of database records” corresponds to a quantity of data processed in a batch.);
Accordingly, it would have been obvious to a person of ordinary skill in the art, before the effective filing date of the claimed invention, having a combination of Laberge and Venkataraman before them, to incorporate measure execution/completion time into Laberge’s chunk-size prediction pipeline. One would have been motivated to make such a combination to align the predictor with the primary scheduling metric (job completion time) and to use the routinely recorded timing information from completed runs. This would allow the model to select chunk size that directly reduce end-to-end job time, improving parallel throughput and efficiency.
Regarding claim 3, Laberge in view of Venkataraman teaches all the elements of claim 1, therefore is rejected for the same reasons as those presented for claim 1. Laberge in view of Venkataraman further teaches:
the machine learning algorithm configured to predict a minimum processing time (Venkataraman, section 6.3 “Consider a case where a user has a fixed-time budget of 1 hour (3600s) to say run 40 iterations of the TIMIT pipeline and an EC2 instance limit of 64 machines. Using Figure 15 and taking our error margin into account, Ernest is able to infer that launching 16 instances is sufficient to meet the deadline. Given that the cost of an r3.xlarge instance is $0.35/hour, a greedy strategy of using all the 64 machines would cost $22.4, while using the 16 machines as predicted by Ernest would only cost $5.6, a 4x difference.” – the ML model’s prediction of execution time is used in a search (the optimization algorithm) to identify the configuration (16 instances) that results in the minimum cost ($5.6), thereby predicting the minimum processing time/resources required.), wherein determining the optimal batch size comprises applying an optimization algorithm to the machine learning algorithm such that a minimum processing time is predicted (Laberge, section 4.3 “The best chunk-size can be calculated by solving the problem:
PNG
media_image1.png
200
400
media_image1.png
Greyscale
We have used supervised learning models to find the solutions of Eq. (4)” – the system is configured to apply an optimization algorithm (argmax) to the ML’s prediction to find the optimal batch size (cs*) that minimizes the processing time.)
Accordingly, it would have been obvious to a person of ordinary skill in the art, before the effective filing date of the claimed invention, having a combination of Laberge and Venkataraman before them, to incorporate the time-based performance prediction and optimization procedure of Venkataraman into the optimal chunk size prediction framework of Laberge. One would have been motivated to make such a combination in order to use the machine learning model’s predicted execution time to directly solve the optimization problem for the optimal batch size, thereby extending the low-level memory-based chunk size selection to large-scale cost-effective cloud resource scheduling.
Regarding claim 4, Laberge in view of Venkataraman teaches all the elements of claim 1, therefore is rejected for the same reasons as those presented for claim 1. Laberge in view of Venkataraman further teaches:
wherein determining the optimal batch size comprises applying the machine learning model to the available resources such that a total predicted processing time is minimized (Venkataraman, section 6.3, “When users have a fixed-time or fixed-cost budget it is often tricky to figure out how many instances should be used for a job as the communication vs. computation trade-off is hard to determine for a given workload… We consider two workloads from the previous section: the TIMIT pipeline and GLM regression, but here we use subsets of the full data to focus on how the job completion time varies as we increase the number of machines to 64. Using the same models trained in the previous section, we predict the time taken per iteration across a wide range of number of machines (Figures 15 and 16)” – using the machine learning model based on the available resources. Laberge, Section 4.3 “we can redefine the abstract feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
. The best chunk-size can be calculated by solving the problem:
PNG
media_image1.png
200
400
media_image1.png
Greyscale
We have used supervised learning models to find the solutions of Eq. (4)” - the number of threads determine the final chunk size.)
Accordingly, it would have been obvious to a person of ordinary skill in the art, before the effective filing date of the claimed invention, having a combination of Laberge and Venkataraman before them, to incorporate the time-based performance prediction and optimization procedure of Venkataraman into the optimal chunk size prediction framework of Laberge. One would have been motivated to make such a combination in order to use the machine learning model’s predicted execution time to directly solve the optimization problem for the optimal batch size, thereby extending the low-level memory-based chunk size selection to large-scale cost-effective cloud resource scheduling.
Regarding claim 5, Laberge in view of Venkataraman teaches all the elements of claim 1, therefore is rejected for the same reasons as those presented for claim 1. Laberge in view of Venkataraman further teaches:
the plurality of variables including a first variable corresponding to a quantity of servers (Venkataraman, section 6.3 “Consider a case where a user has a fixed-time budget of 1 hour (3600s) to say run 40 iterations of the TIMIT pipeline and an EC2 instance limit of 64 machines. Using Figure 15 and taking our error margin into account, Ernest is able to infer that launching 16 instances” – machine/instances on EC2 are servers.)and a second variable corresponding to a batch size (Laberge, section 4.3 “which outputs an approximation of the best chunk-size for any new example
c
s
^
*
” – cs is the variable for the chunk/batch size)
Regarding claim 6, Laberge in view of Venkataraman teaches all the elements of claim 1, therefore is rejected for the same reasons as those presented for claim 1. Laberge in view of Venkataraman further teaches:
the plurality of variables including a first variable corresponding to a quantity of threads (Laberge, Section 4.3 “we can redefine the abstract feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
” – the variable
N
t
h
r
is the number of threads.) and a second variable corresponding to a quantity of database connections (Venkataraman, section 2.1 “In the system modeling approach, a performance model is developed based on the properties of the system being studied. This method has been used in scientific computing [16] for compilers [11], programming models [21, 27]; and by databases [29, 57] for estimating the progress made by SQL queries” – refers to databases/SQL queries which inherently involves opening up database connections.).
Regarding claim 8, Laberge teaches the limitation:
training, by at least one processor, a machine learning model using historical data, the machine learning model having a plurality of weights, each weight corresponding to one of a plurality of variables (Laberge, Abstract “In the realm of Asynchronous Many Task runtime systems, a key aspect of the scheduling problem is predicting the proper chunk-size, where the chunk-size is defined as the number of iterations of a for-loop assigned to a thread as one task. In this paper, we study the applications of supervised learning models to predict the chunk-size which yields maximum performance on multiple parallel linear algebra operations using the HPX backend of Blaze’s linear algebra library…We compare the use of logistic regression, neural networks and decision trees with a newly developed decision tree based model in order to predict the optimal value for chunk-size.” -models with parameters/weights over input features. Section 4.3 - “Once the approximation of the best block-size is computed for any
o
t
and
a
r
, we can redefine the abstract feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
.” - variables to determine chunk/batch size.) , the historical data including a plurality of training data sets (Abstract, “we generate our training and tests sets by measuring performance of the application with different chunk-sizes for multiple linear algebra operations” – historical data, prior runs), each training data set including resource characteristics of resources consumed during a previously executed parallel batch process (section 3.3, the paper describes the “
a
r
” (architecture), and
N
t
h
r
(
number of threads) as the resources available to determine chunk size (batch size) ), a size of a data set processed during the previously executed parallel batch process, a batch size of the previously executed parallel batch process (Abstract, “we generate our training and tests sets by measuring performance of the application with different chunk-sizes” and Section 4.3, “Once the approximation of the best block-size is computed for any
o
t
and
a
r
, we can redefine the abstract feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
. The best chunk-size can be calculated by solving the problem:… “ (equation 4) – the training/test sets are built from previous executions, and each example’s features include
m
s
(problem/data size) – i.e., the size of the dataset processed in these prior runs. Because each prior run in the training data stores performance for each chunk/batch size cs, the batch size used in previously executed processes is explicitly captured.), and a processing time associated with the previously executed parallel batch process ;
determining, by at least one processor, a size of a subsequent data set, size of the subsequent data set including a first quantity of database records (Laberge, section 4.5 “Run-time features like
m
s
(matrix size/data size)… can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
function and Blaze’s
m
a
t
r
i
x
.
c
o
l
s
member function for Matrix/Vector classes” ” – under the broadest reasonable interpretation, a “first quantity of database records” corresponds to a size of a dataset, i.e., amount of data being processed. Laberge’s matrix size (ms), which represents the size of the data being processed, therefore corresponds to the claimed first quantity of database records.); ascertaining, by at least one processor, the available resources including one or more of a quantity of servers, central processing unit resources, amount of memory, quantity of threads, or quantity of database connections (section 4.5, “Run-time features like
m
s
and
N
t
h
r
(resources available) can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
” - Laberge’s N_thr represents the number of threads available for execution, which corresponds to the claimed quantity of threads as one of the available resources.); determining, by at least one processor, using the machine learning model, an optimal batch size for the subsequent data set based, at least in part, on the available resources and the size of the subsequent data set (Laberge, section 4.3 –“Estimating the Best Chunk-size” and “feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
…
We have used supervised learning models to find the solutions of Eq. (4) for any arbitrary value of the feature vector
x
→
.
The advantage of machine learning methods is that they can output predictions pretty fast. Therefore, the selection of the optimal chunk-size can be done seamlessly in Blaze…Our goal is to find a black-box model fed with a brut training set
x
→
i
;
P
e
r
x
→
i
;
c
s
∀
c
s
∈
C
S
N
i
=
1
,
which outputs an approximation of the best chunk-size for any new example
c
s
^
=
f
x
→
n
e
w
(where the hat symbols stands for approximation).”); and processing, by at least one processor, the subsequent data set by performing parallel processing using the available resources according to the optimal batch size (Section 3.2 – Parallelization Framework, “The elements of an expression are only evaluated when the assignment operator is called, i.e.
C
=
E
x
p
r
e
s
s
i
o
n
T
e
m
p
l
a
t
e
(
A
,
B
)
. During an assignment, the elements of the expression template are evaluated and the results are stored in
C
. This step can be parallelized since each component of
C
is independently computed. Figure 1 shows how work is distributed among threads and introduces the two critical parameters involved: block-size and chunk-size. In this work, we demonstrate the use of machine learning to simplify the task of selecting the chunk sizes, given a specified block-size.” and Abstract, “predicting the proper chunk-size, where the chunk-size is defined as the number of iterations of a for-loop assigned to a thread as one task.”)
However, Laberge does not teach, but Venkataraman does teach:
A system comprising: a database system implemented using a server system, the database system configurable to cause (Ernst, Section 2.2 “The widespread adoption of cloud computing has led to a large number of data analysis jobs being run on cloud computing platforms like Amazon EC2, Microsoft Azure and Google Compute Engine.” – Ernst teaches a database system implemented on a server system: it runs jobs on cloud server platforms (e.g., Amazon EC2 instances) and explicitly includes databases/SQL queries in its modeling scope – so the data system operates atop the server system):
and a processing time associated with the previously executed parallel batch process (Venkataraman, section 3.1, “To build our model we add terms related to the computation
and communication patterns…The terms we add to our linear model are (a) a fixed cost
term which represents the amount of time spent in serial computation (b) the interaction between the scale and the inverse of the number of machines; this is to capture the
parallel computation time… (c) a log(machines) term to model communication patterns… (d) a linear term O(machines) which captures the all-to-one communication pattern and fixed overheads…Thus the overall model we are fitting tries to learn values for…in the formula” - describes the features used in the linear model where the dependent variable is the total processing time. The subsequent formula shown in the paper explicitly models this total time.);
wherein determining the optimal batch size comprises performing gradient descent, the optimal batch size for the subsequent data set including a second quantity of database records (Venkataraman, [page 364, Introduction] “a mini-batch gradient descent algorithm used for linear regression. Laberge, [section 4.5] “Run-time features like
m
s
(matrix size/data size)… can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
( ) function and Blaze’s
m
a
t
r
i
x
.
c
o
l
s
member function for Matrix/Vector classes” – Venkataraman teaches performing gradient descent (e.g., mini-batch gradient descent) in a machine-learning context. Under BRI, “comprising performing gradient descent” requires only gradient descent be performed as part of the process. Further, as discussed above, Laberge’s data size (ms) corresponds to a quantity of database records” corresponds to a quantity of data processed in a batch.);
Accordingly, it would have been obvious to a person of ordinary skill in the art, before the effective filing date of the claimed invention, having a combination of Laberge and Venkataraman before them, to incorporate measure execution/completion time into Laberge’s chunk-size prediction pipeline. One would have been motivated to make such a combination to align the predictor with the primary scheduling metric (job completion time) and to use the routinely recorded timing information from completed runs. This would allow the model to select chunk size that directly reduce end-to-end job time, improving parallel throughput and efficiency.
Regarding claim 10, Laberge in view of Venkataraman teaches all the elements of claim 8, therefore is rejected for the same reasons as those presented for claim 8. The claim recites similar limitations corresponding to claim 3 and is rejected for similar reasons as claim 3 using similar teachings and rationale.
Regarding claim 11, Laberge in view of Venkataraman teaches all the elements of claim 8, therefore is rejected for the same reasons as those presented for claim 8. The claim recites similar limitations corresponding to claim 4 and is rejected for similar reasons as claim 4 using similar teachings and rationale.
Regarding claim 12, Laberge in view of Venkataraman teaches all the elements of claim 8, therefore is rejected for the same reasons as those presented for claim 8. The claim recites similar limitations corresponding to claim 5 and is rejected for similar reasons as claim 5 using similar teachings and rationale.
Regarding claim 13, Laberge in view of Venkataraman teaches all the elements of claim 8, therefore is rejected for the same reasons as those presented for claim 8. The claim recites similar limitations corresponding to claim 6 and is rejected for similar reasons as claim 6 using similar teachings and rationale.
Regarding claim 15, Laberge teaches the limitation:
training a machine learning model using historical data, the machine learning model having a plurality of weights, each weight corresponding to one of a plurality of variables (Laberge, Abstract “In the realm of Asynchronous Many Task runtime systems, a key aspect of the scheduling problem is predicting the proper chunk-size, where the chunk-size is defined as the number of iterations of a for-loop assigned to a thread as one task. In this paper, we study the applications of supervised learning models to predict the chunk-size which yields maximum performance on multiple parallel linear algebra operations using the HPX backend of Blaze’s linear algebra library…We compare the use of logistic regression, neural networks and decision trees with a newly developed decision tree based model in order to predict the optimal value for chunk-size.” -models with parameters/weights over input features. Section 4.3 - “Once the approximation of the best block-size is computed for any
o
t
and
a
r
, we can redefine the abstract feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
.” - variables to determine chunk/batch size.) , the historical data including a plurality of training data sets (Abstract, “we generate our training and tests sets by measuring performance of the application with different chunk-sizes for multiple linear algebra operations” – historical data, prior runs), each training data set including resource characteristics of resources consumed during a previously executed parallel batch process (section 3.3, the paper describes the “
a
r
” (architecture), and
N
t
h
r
(
number of threads) as the resources available to determine chunk size (batch size) ), a size of a data set processed during the previously executed parallel batch process, a batch size of the previously executed parallel batch process (Abstract, “we generate our training and tests sets by measuring performance of the application with different chunk-sizes” and Section 4.3, “Once the approximation of the best block-size is computed for any
o
t
and
a
r
, we can redefine the abstract feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
. The best chunk-size can be calculated by solving the problem:… “ (equation 4) – the training/test sets are built from previous executions, and each example’s features include
m
s
(problem/data size) – i.e., the size of the dataset processed in these prior runs. Because each prior run in the training data stores performance for each chunk/batch size cs, the batch size used in previously executed processes is explicitly captured.), and a processing time associated with the previously executed parallel batch process ;
determining, by at least one processor, a size of a subsequent data set, size of the subsequent data set including a first quantity of database records (Laberge, section 4.5 “Run-time features like
m
s
(matrix size/data size)… can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
function and Blaze’s
m
a
t
r
i
x
.
c
o
l
s
member function for Matrix/Vector classes” ” – under the broadest reasonable interpretation, a “first quantity of database records” corresponds to a size of a dataset, i.e., amount of data being processed. Laberge’s matrix size (ms), which represents the size of the data being processed, therefore corresponds to the claimed first quantity of database records.); ascertaining, by at least one processor, the available resources including one or more of a quantity of servers, central processing unit resources, amount of memory, quantity of threads, or quantity of database connections (section 4.5, “Run-time features like
m
s
and
N
t
h
r
(resources available) can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
” - Laberge’s N_thr represents the number of threads available for execution, which corresponds to the claimed quantity of threads as one of the available resources.); determining, by at least one processor, using the machine learning model, an optimal batch size for the subsequent data set based, at least in part, on the available resources and the size of the subsequent data set (Laberge, section 4.3 –“Estimating the Best Chunk-size” and “feature vector
x
→
=
m
s
,
N
t
h
r
,
o
t
,
a
r
,
b
*
…
We have used supervised learning models to find the solutions of Eq. (4) for any arbitrary value of the feature vector
x
→
.
The advantage of machine learning methods is that they can output predictions pretty fast. Therefore, the selection of the optimal chunk-size can be done seamlessly in Blaze…Our goal is to find a black-box model fed with a brut training set
x
→
i
;
P
e
r
x
→
i
;
c
s
∀
c
s
∈
C
S
N
i
=
1
,
which outputs an approximation of the best chunk-size for any new example
c
s
^
=
f
x
→
n
e
w
(where the hat symbols stands for approximation).”) and processing, by the at least one processor, the subsequent data set by performing parallel processing using the available resources according to the optimal batch size (Section 3.2 – Parallelization Framework, “The elements of an expression are only evaluated when the assignment operator is called, i.e.
C
=
E
x
p
r
e
s
s
i
o
n
T
e
m
p
l
a
t
e
(
A
,
B
)
. During an assignment, the elements of the expression template are evaluated and the results are stored in
C
. This step can be parallelized since each component of
C
is independently computed. Figure 1 shows how work is distributed among threads and introduces the two critical parameters involved: block-size and chunk-size. In this work, we demonstrate the use of machine learning to simplify the task of selecting the chunk sizes, given a specified block-size.” and Abstract, “predicting the proper chunk-size, where the chunk-size is defined as the number of iterations of a for-loop assigned to a thread as one task.”)
However, Laberge does not teach, but Venkataraman does teach:
A non-transitory computer-readable storage medium comprising computer-readable program code capable of being executed by one or more processors, the program code comprising computer-readable instructions configurable to cause (Venkataraman, section 4 “Ernest is implemented using Python as multiple modules. The modules include a job submission tool that submits training jobs, a training data selection process which implements experiment design using a CVX solver [42, 41] and finally a model builder that uses NNLS from SciPy [53 section Ernst discloses executable program code” and section 5.1 “As Ernest treats the job being run as a black-box, we will need to retrain the model for any changes to the code. This can be detected by computing hashes of the binary files.” – Venkataraman discloses executable program code (Python modules/JAR) that is retrieved from persistent storage and run on EC2 processors (vCPUs), with configurable instructions (submission parameters/model-guided choices) that can cause the subsequent steps of the method to occur.):
and a processing time associated with the previously executed parallel batch process (Venkataraman, section 3.1, “To build our model we add terms related to the computation
and communication patterns…The terms we add to our linear model are (a) a fixed cost
term which represents the amount of time spent in serial computation (b) the interaction between the scale and the inverse of the number of machines; this is to capture the
parallel computation time… (c) a log(machines) term to model communication patterns… (d) a linear term O(machines) which captures the all-to-one communication pattern and fixed overheads…Thus the overall model we are fitting tries to learn values for…in the formula” - describes the features used in the linear model where the dependent variable is the total processing time. The subsequent formula shown in the paper explicitly models this total time.);
wherein determining the optimal batch size comprises performing gradient descent, the optimal batch size for the subsequent data set including a second quantity of database records (Venkataraman, [page 364, Introduction] “a mini-batch gradient descent algorithm used for linear regression. Laberge, [section 4.5] “Run-time features like
m
s
(matrix size/data size)… can be extracted at run-time with HPX’s
g
e
t
n
u
m
t
h
r
e
a
d
s
( ) function and Blaze’s
m
a
t
r
i
x
.
c
o
l
s
member function for Matrix/Vector classes” – Venkataraman teaches performing gradient descent (e.g., mini-batch gradient descent) in a machine-learning context. Under BRI, “comprising performing gradient descent” requires only gradient descent be performed as part of the process. Further, as discussed above, Laberge’s data size (ms) corresponds to a quantity of database records” corresponds to a quantity of data processed in a batch.);
Accordingly, it would have been obvious to a person of ordinary skill in the art, before the effective filing date of the claimed invention, having a combination of Laberge and Venkataraman before them, to incorporate measure execution/completion time into Laberge’s chunk-size prediction pipeline. One would have been motivated to make such a combination to align the predictor with the primary scheduling metric (job completion time) and to use the routinely recorded timing information from completed runs. This would allow the model to select chunk size that directly reduce end-to-end job time, improving parallel throughput and efficiency.
Regarding claim 17, Laberge in view of Venkataraman teaches all the elements of claim 15, therefore is rejected for the same reasons as those presented for claim 15. The claim recites similar limitations corresponding to claim 3 and is rejected for similar reasons as claim 3 using similar teachings and rationale.
Regarding claim 18, Laberge in view of Venkataraman teaches all the elements of claim 15, therefore is rejected for the same reasons as those presented for claim 15. The claim recites similar limitations corresponding to claim 4 and is rejected for similar reasons as claim 4 using similar teachings and rationale.
Regarding claim 19, Laberge in view of Venkataraman teaches all the elements of claim 15, therefore is rejected for the same reasons as those presented for claim 15. The claim recites similar limitations corresponding to claim 5 and is rejected for similar reasons as claim 5 using similar teachings and rationale.
Regarding claim 20, Laberge in view of Venkataraman teaches all the elements of claim 15, therefore is rejected for the same reasons as those presented for claim 15. The claim recites similar limitations corresponding to claim 6 and is rejected for similar reasons as claim 6 using similar teachings and rationale.
Conclusion
Applicant's amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to Daravanh Phakousonh whose telephone number is (571)272-6324. The examiner can normally be reached Mon - Thurs 7 AM - 5 PM, Every other Friday 7 AM - 4PM.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Li B Zhen can be reached at 571-272-3768. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/Daravanh Phakousonh/Examiner, Art Unit 2121
/Li B. Zhen/Supervisory Patent Examiner, Art Unit 2121
Prosecution Insights