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 .
Information Disclosure Statement
The information disclosure statement (IDS) submitted on 01/10/2023; 10/19/2023; 08/27/2024; 06/11/2025 is in compliance with the provisions of 37 CFR 1.97. Accordingly, the information disclosure statement is being considered by the examiner.
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.
The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows:
1. Determining the scope and contents of the prior art.
2. Ascertaining the differences between the prior art and the claims at issue.
3. Resolving the level of ordinary skill in the pertinent art.
4. Considering objective evidence present in the application indicating obviousness or nonobviousness.
Claim(s) 1, 5-10, 12-13, 17-21 are rejected under 35 U.S.C. 103 as being unpatentable over Carreira et al. (“Massively Parallel Video Networks”) (hereafter referred to as “Carreira”) in further view of Buck et al. (US 2005/0125369 A1) (hereafter referred to as “Buck”)
Regarding claim 1, Carreira explicitly discloses:
A computer-implemented method of training a neural network configured
to process an input sequence and to generate a network output for the input sequence, wherein: (Carreira, Pg. 3, Figure 1: “Illustration of a standard sequential video model that processes frames independently, and depth-parallel versions. The horizontal direction represents the time and the vertical direction represents the depth of the network. The throughput of the basic image model depicted in (a) can be increased for real-time video processing using depth-parallelisation, shown in (b). This makes it possible to, given a new frame, process all layers in parallel, increasing throughput if parallel resources are available.
But this also introduces a delay of a few frames- in this example, the output at time t
corresponds to the input at time t-3. It is possible to train the network to anticipate
the correct output in order to reduce the latency (c). This task can be made easier if
the model has skip-connections, as illustrated in (d) - this way the model has access
to some fresh features (albeit these fresh features have limited computational depth). these methods still use purely sequential processing in depth (all layers must
execute before proceeding to a next input). Moreover, they are not causal - the
3D convolutional kernels extract features from future frames, which makes it
challenging to use these models in real-time.”
PNG
media_image1.png
229
683
media_image1.png
Greyscale
)
the neural network generates a respective output item for each of a plurality of input items in the input sequence, and (Carreira, Pg. 3, Figure 1: “Illustration of a standard sequential video model that processes frames independently, and depth-parallel versions. The horizontal direction represents the time and the vertical direction represents the depth of the network. The throughput of the basic image model depicted in (a) can be increased for real-time video processing using depth-parallelisation, shown in (b). This makes it possible to, given a new frame, process all layers in parallel, increasing throughput if parallel resources are available.
But this also introduces a delay of a few frames- in this example, the output at time t
corresponds to the input at time t-3. It is possible to train the network to anticipate the correct output in order to reduce the latency (c).)
the neural network comprises a stack of layer blocks, each layer block comprising one or more neural network layers, the stack of layer blocks comprising a first layer block and a final layer block, (Carreira, Pg. 5, ¶[3]: “A simple strategy to transform an image model with a linear-chain layer-architecture into a semi-parallel video model is to traverse the network starting from the first layer, and group together contiguous layers into sequential blocks of k layers that we will call parallel subnetworks and which can execute independently”, Pg. 6, Figure 3: “Left: neural networks with three parallel subnetworks of two layers and two parallel subnetworks of three layers.”
PNG
media_image2.png
291
249
media_image2.png
Greyscale
)
wherein the training comprises: receiving an input sequence comprising a respective input item at each of a plurality of input time steps; and (Carreira, Pg. 34, ¶[2]: “In the proposed design, every layer in the network processes its input, passes the activations to the next layer, and immediately starts processing the next input available, without waiting for the whole network to finish computation for the current frame; Fg. 1 (b). This is achieved by substituting in the unrolled graph the vertical edges by diagonal ones, so the input to each layer is still the output from the previous layer, as usual, but from the previous time step. This makes it possible to process all layers at one time step in parallel, given enough computing cores, since there are no dependencies between them.”)
at each of a plurality of processing time steps in a sequence of processing time steps:
processing the input item of an input time step corresponding to the processing time
step using the first layer block to generate a first block output; (Carreira, Pg. 19, Fig. 11:
PNG
media_image3.png
683
815
media_image3.png
Greyscale
) [Examiner’s note: the pseudocode of Fig. 11 discloses the claimed feature. Specifically, at each time step t, an input frame I[t] is provided into the system (line 7). The first layer block layer[0] operates on this input (line 13) to generate an output, which is appended to outputs[0]. This output corresponds to the claimed “first block output”]
for each particular layer block that is not the first layer block, processing a block output generated by the preceding layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps using the particular layer block to generate a current block output, (Carreira, Pg. 4, ¶[2]: “In basic depth-sequential video models, the input to each layer is the output of the previous layer at the same time step, and the network outputs a prediction only after all the layers have processed in sequence the current frame; see fig. 1 (a).”)
wherein the current block output generated by the final layer block is the output item for an input item of an earlier input time step than the input time step corresponding to the processing time step; (Carreira, Pg. 3, Fig. 1: “This makes it possible to, given a new frame, process all layers in parallel, increasing throughput if parallel resources are available. But this also introduces a delay of a few frames - in this example, the output at time t corresponds to the input at time t-3. It is possible to train the network to anticipate the correct output in order to reduce the latency”, Figure 1(b):
PNG
media_image4.png
227
173
media_image4.png
Greyscale
)
Carreira fails to disclose:
computing i) a current error in the output item generated by the final layer block at the
processing time step and ii) a current gradient of the current error for the final layer block
generating a parameter update for the final layer block from the current error in the
output item;
for each particular layer block that is not the final layer block, computing a current gradient for the particular layer block from i) a preceding gradient computed by the subsequent layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps and ii) the preceding block output generated by the preceding layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps; and
for each particular layer block that is not the final layer block, generating a parameter update for the particular layer block from the preceding gradient computed by the subsequent layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps.
However, Buck explicitly discloses:
computing i) a current error in the output item generated by the final layer block at the
processing time step and ii) a current gradient of the current error for the final layer block (Buck, ¶[0055]: “The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others. The cost function provided the gradients, or how much each variable
affects the cost and in which direction, for each variable. This gradient is computed for each variable and parameters in the system. The parameters W are updated in order to
decrease the cost function.”)
generating a parameter update for the final layer block from the current error in the
output item; (Buck, ¶[0055]: ]: “The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others. The cost function provided the gradients, or how much each variable affects the cost and in which direction, for each variable. This gradient is computed for each variable and parameters in the system. The parameters W are updated in order to decrease the cost function.”)
for each particular layer block that is not the final layer block, computing a current gradient for the particular layer block from i) a preceding gradient computed by the subsequent layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps and ii) the preceding block output generated by the preceding layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps; and (Buck, ¶[0054]: “In this example, the learning machine optimization is performed by using gradient descent… The parameters are denoted W (W1 , W2 , W3 ). The input of the whole module is X and the output is Y=Y3.” ¶[0055]: ]: “The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others. The cost function provided the gradients, or how much each variable affects the cost and in which direction, for each variable. This gradient is computed for each variable and parameters in the system. The parameters W are updated in order to decrease the cost function.”)
for each particular layer block that is not the final layer block, generating a parameter update for the particular layer block from the preceding gradient computed by the subsequent layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps. (Buck, ¶[0054]: “In this example, the learning machine optimization is performed by using gradient descent… The parameters are denoted W (W1 , W2 , W3 ). The input of the whole module is X and the output is Y=Y3.” ¶[0055]: ]: “The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others. The cost function provided the gradients, or how much each variable affects the cost and in which direction, for each variable. This gradient is computed for each variable and parameters in the system. The parameters W are updated in order to decrease the cost function.”)
It would have obvious to one of ordinary skill in the art before the effective filing date of the present application to combine Carreira and Buck. Carreira teaches a massively parallel video networks. Buck teaches system and method for processing machine learning techniques (such as neural networks) and other non-graphics applications using a graphics processing unit (GPU) to accelerate and optimize the processing. One of ordinary skill would have motivation to combine Carreira and Buck to provide the neural network with a clear learning signal that guides improvement. By measuring how far the prediction deviates from the desired output, the model knows what needs correcting. The gradient then indicates the most effective direction to adjust the final layer’s parameters, ensuring updates are purposeful rather than random. Applying this update reduces future errors, allowing the network to iteratively refine its performance and progressively learn the target mapping.
Regarding Claim 5, the combination of Carreira and Buck discloses all the limitations of claim 1 (as shown in the rejections above).
Carreira in view of Buck further discloses:
computing a first Jacobian of the particular layer block with respect to the block output generated by the preceding layer block in the stack of layer blocks at the preceding processing time step; and (Buck, ¶[0055]: “Each layer communicates with neighbors by computing a function of its input (forward pass), and by propagating the derivative of its output, which is obtained by multiplying the output gradient, denoted dE/dY by its Jacobian's transpose. This is the backward pass. By definition, the Jacobian J of G is a matrix Jki=dYk/dXi where k indexes the k-th output, and i indexes the i-th input of function G. The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others.”)
multiplying the first Jacobian with the preceding gradient computed by the subsequent layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps. (Buck, ¶[0055]: “Each layer communicates with neighbors by computing a function of its input (forward pass), and by propagating the derivative of its output, which is obtained by multiplying the output gradient, denoted dE/dY by its Jacobian's transpose. This is the backward pass. By definition, the Jacobian J of G is a matrix Jki=dYk/dXi where k indexes the k-th output, and i indexes the i-th input of function G. The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others.”)
Regarding Claim 6, the combination of Carreira and Buck discloses all the limitations of claim 1 (as shown in the rejections above).
Carreira in view of Buck further discloses:
wherein computing a current gradient for the final layer block comprises: computing a first Jacobian of the final layer block with respect to the block output generated by the preceding layer block in the stack of layer blocks at the preceding processing time step. (Buck, ¶[0055]: “Each layer communicates with neighbors by computing a function of its input (forward pass), and by propagating the derivative of its output, which is obtained by multiplying the output gradient, denoted dE/dY by its Jacobian's transpose. This is the backward pass. By definition, the Jacobian J of G is a matrix Jki=dYk/dXi where k indexes the k-th output, and i indexes the i-th input of function G. The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others.”)
Regarding Claim 7, the combination of Carreira and Buck discloses all the limitations of claim 1 (as shown in the rejections above).
Carreira in view of Buck further discloses:
wherein generating a parameter update for a particular layer block that is not the final layer block comprises: generating a second gradient for the particular layer block, comprising: (Buck, ¶[0064]: “For stochastic gradient descent, the learning parameters are updated after processing each pattern in the group. For batch gradient descent, the learning parameter gradients are accumulated over several patterns before the learning parameters are updated.”)
computing a second Jacobian of the particular layer block with respect to current values of the parameters of the particular layer block; and (Buck, ¶[0055]: “Each layer communicates with neighbors by computing a function of its input (forward pass), and by propagating the derivative of its output, which is obtained by multiplying the output gradient, denoted dE/dY by its Jacobian's transpose. This is the backward pass. By definition, the Jacobian J of G is a matrix Jki=dYk/dXi where k indexes the k-th output, and i indexes the i-th input of function G. The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others.”)
multiplying the second Jacobian with the preceding gradient computed by the subsequent layer block in the stack of layer blocks at the preceding processing time step in the sequence of processing time steps; and (Buck, ¶[0055]: “Each layer communicates with neighbors by computing a function of its input (forward pass), and by propagating the derivative of its output, which is obtained by multiplying the output gradient, denoted dE/dY by its Jacobian's transpose. This is the backward pass. By definition, the Jacobian J of G is a matrix Jki=dYk/dXi where k indexes the k-th output, and i indexes the i-th input of function G. The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others.”)
generating the parameter update from the second gradient. (Buck, ¶[0063]: “An
error 555 between G(X',W) and (T) is computed, and error signals (such as gradient with respect to W) are sent back to the learning machine 550. The weights (W) then are updated in order to reduce the error between G(X',W) and (T).”)
Regarding Claim 8, the combination of Carreira and Buck discloses all the limitations of claim 1 (as shown in the rejections above).
Carreira in view of Buck further discloses:
wherein generating a parameter update for the final layer block comprises: generating a second gradient for the final layer block, comprising: (Buck, ¶[0064]: “For stochastic gradient descent, the learning parameters are updated after processing each pattern in the group. For batch gradient descent, the learning parameter gradients are accumulated over several patterns before the learning parameters are updated.”)
computing a second Jacobian of the final layer block with respect to current values of the parameters of the final layer block; and (Buck, ¶[0055]: “Each layer communicates with neighbors by computing a function of its input (forward pass), and by propagating the derivative of its output, which is obtained by multiplying the output gradient, denoted dE/dY by its Jacobian's transpose. This is the backward pass. By definition, the Jacobian J of G is a matrix Jki=dYk/dXi where k indexes the k-th output, and i indexes the i-th input of function G. The error function E compares the output of the last layer to a target T using a cost function. Examples of different cost functions can be mean squared error (MSE), cross-entropy (CE), or others.”)
generating the parameter update from the second gradient. (Buck, ¶[0063]: “An
error 555 between G(X',W) and (T) is computed, and error signals (such as gradient with respect to W) are sent back to the learning machine 550. The weights (W) then are updated in order to reduce the error between G(X',W) and (T).”)
Regarding Claim 9, the combination of Carreira and Buck discloses all the limitations of claim 1 (as shown in the rejections above).
Carreira in view of Buck further discloses:
wherein generating a parameter update comprises generating the parameter update using stochastic gradient descent. (Buck, ¶[0063]: “An error 555 between G(X',W) and (T) is computed, and error signals (such as gradient with respect to W) are sent back to the learning machine 550. The weights (W) then are updated in order to reduce the error between G(X',W) and (T).”)
Regarding Claim 10, the combination of Carreira and Buck discloses all the limitations of claim 1 (as shown in the rejections above).
Carreira in view of Buck further discloses:
combining the parameter updates for the layer block generated at a plurality of respective processing time steps to generate a combined parameter update, and (Buck, ¶[0152]: “The weight update was performed by performing an outer product of the error vector and the input vector of the layer. The resulting matrix was scaled by the learning coefficient, and added into the existing weight matrix.”)
updating parameters of the layer block using the combined parameter update. (Buck, ¶[0152]: “The weight update was performed by performing an outer product of the error vector and the input vector of the layer. The resulting matrix was scaled by the learning coefficient, and added into the existing weight matrix. To propagate the error up the network, another matrix vector multiply was computed. Namely, the transpose of the weight matrix with the error vector was computed, again scaled by the D(x) function.”)
Referring to independent Claim 12 and Claim 13, they are rejected on the same basis as independent Claim 1 since they are analogous claims.
Referring to dependent Claim 17, it is rejected on the same basis as dependent Claim 5 since they are analogous claims.
Referring to dependent Claim 18, it is rejected on the same basis as dependent Claim 6 since they are analogous claims.
Referring to dependent Claim 19, it is rejected on the same basis as dependent Claim 7 since they are analogous claims.
Referring to dependent Claim 20, it is rejected on the same basis as dependent Claim 8 since they are analogous claims.
Referring to dependent Claim 21, it is rejected on the same basis as dependent Claim 9 since they are analogous claims.
Allowable Subject Matter
Claims 2-4 and 14-16 are objected to as being dependent upon a rejected base claim, but would be allowable if rewritten in independent form including all of the limitations of the base claim and any intervening claims.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to AMY TRAN whose telephone number is (571)270-0693. The examiner can normally be reached Monday - Friday 7:30 am - 5:00 pm EST.
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, David Yi can be reached at (571) 270-7519. 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.
/AMY TRAN/ Examiner, Art Unit 2126
/DAVID YI/Supervisory Patent Examiner, Art Unit 2126