Surveillance Camera Upgrade via Removable Media having Deep Learning Accelerator and Random Access Memory

Abstract

Systems, devices, and methods related to a deep learning accelerator and memory are described. For example, a removable media (e.g., a memory card, or a USB drive) may be configured to execute instructions with matrix operands and configured with: an interface to receive a video stream; and random access memory to buffer a portion of the video stream as an input to an artificial neural network and to store instructions executable by the deep learning accelerator and matrices of the artificial neural network. Such a removable media can be used to replace an existing removable media used in a surveillance camera to record video or images. The deep learning accelerator can execute the instructions to generate analytics of the buffer portion using the artificial neural network, enabling the surveillance camera that is upgraded via the use of the removable media to provide intelligent services based on the analytics.

Description

TECHNICAL FIELD

At least some embodiments disclosed herein relate to surveillance camera in general and more particularly, but not limited to, intelligent surveillance camera powered by artificial neural networks (ANNs), such as ANNs configured through machine learning and/or deep learning.

BACKGROUND

An artificial neural network (ANN) uses a network of neurons to process inputs to the network and to generate outputs from the network.

For example, each neuron in the network receives a set of inputs. Some of the inputs to a neuron may be the outputs of certain neurons in the network; and some of the inputs to a neuron may be the inputs provided to the neural network. The input/output relations among the neurons in the network represent the neuron connectivity in the network.

For example, each neuron can have a bias, an activation function, and a set of synaptic weights for its inputs respectively. The activation function may be in the form of a step function, a linear function, a log-sigmoid function, etc. Different neurons in the network may have different activation functions.

For example, each neuron can generate a weighted sum of its inputs and its bias and then produce an output that is the function of the weighted sum, computed using the activation function of the neuron.

The relations between the input(s) and the output(s) of an ANN in general are defined by an ANN model that includes the data representing the connectivity of the neurons in the network, as well as the bias, activation function, and synaptic weights of each neuron. Based on a given ANN model, a computing device can be configured to compute the output(s) of the network from a given set of inputs to the network.

For example, the inputs to an ANN network may be generated based on camera inputs; and the outputs from the ANN network may be the identification of an item, such as an event or an object.

In general, an ANN may be trained using a supervised method where the parameters in the ANN are adjusted to minimize or reduce the error between known outputs associated with or resulted from respective inputs and computed outputs generated via applying the inputs to the ANN. Examples of supervised learning/training methods include reinforcement learning and learning with error correction.

Alternatively, or in combination, an ANN may be trained using an unsupervised method where the exact outputs resulted from a given set of inputs is not known before the completion of the training. The ANN can be trained to classify an item into a plurality of categories, or data points into clusters.

Multiple training algorithms can be employed for a sophisticated machine learning/training paradigm.

Deep learning uses multiple layers of machine learning to progressively extract features from input data. For example, lower layers can be configured to identify edges in an image; and higher layers can be configured to identify, based on the edges detected using the lower layers, items captured in the image, such as faces, objects, events, etc. Deep learning can be implemented via artificial neural networks (ANNs), such as deep neural networks, deep belief networks, recurrent neural networks, and/or convolutional neural networks.

Deep learning has been applied to many application fields, such as computer vision, speech/audio recognition, natural language processing, machine translation, bioinformatics, drug design, medical image processing, games, etc.

BRIEF DESCRIPTION OF THE DRAWINGS

The embodiments are illustrated by way of example and not limitation in the figures of the accompanying drawings in which like references indicate similar elements.

FIG. 1 shows an integrated circuit device having a deep learning accelerator and random access memory configured according to one embodiment.

FIG. 2 shows a processing unit configured to perform matrix-matrix operations according to one embodiment.

FIG. 3 shows a processing unit configured to perform matrix-vector operations according to one embodiment.

FIG. 4 shows a processing unit configured to perform vector-vector operations according to one embodiment.

FIG. 5 shows a deep learning accelerator and random access memory configured to autonomously apply inputs to a trained artificial neural network according to one embodiment.

FIG. 6 illustrates a technique to upgrade a surveillance camera using a removable media according to one embodiment.

FIGS. 7-9 illustrate removable media having a deep learning accelerator and random access memory configured according to some embodiments.

FIG. 10 shows a method implemented in a surveillance camera according to one embodiment.

DETAILED DESCRIPTION

At least some embodiments disclosed herein provide a removable media that has a general-purpose integrated circuit configured to perform computations of artificial neural networks (ANNs) with reduced energy consumption and computation time. The integrated circuit includes a deep learning accelerator (DLA) and random access memory. Such a removable media can be inserted into a surveillance camera as a replacement storage device. The insertion of the removable media into the surveillance camera further upgrades the surveillance camera to include the capabilities of generating video analytics using the integrated circuit according to an artificial neural network (ANN).

For example, input video data stored into the removable media can be analyzed by an artificial neural network to generate analytics and/or inference results. The analytics and/or inference results can be used in video compression performed by a video encoder. The compressed video having a size smaller than the input video data can be stored in the removable media as a replacement of the input video data and can be retrieved to playback the video for a presentation that is substantially the same was the playback of the input video data.

Alternatively, or in combination, the analytics and/or inference results can be used to generate intelligent outputs that are less voluminous than the video data. For example, the artificial neural network (ANN) can be trained to output recognized events, patterns, features, or classifications that are of interest in a particular surveillance application. The outputs can be stored in the removable media, used to generate alerts, transmitted from the surveillance camera to a separate computing system, and/or used to selectively retain and/or transmit video data generated in the surveillance camera.

The deep learning accelerator (DLA) includes a set of general-purpose, programmable hardware computing logic that is specialized and/or optimized to perform parallel vector and/or matrix calculations, including but not limited to multiplication and accumulation of vectors and/or matrices.

Further, the deep learning accelerator (DLA) can include one or more arithmetic-logic units (ALUs) to perform arithmetic and bitwise operations on integer binary numbers.

The deep learning accelerator (DLA) is programmable via a set of instructions to perform the computations of an artificial neural network (ANN).

The granularity of the deep learning accelerator (DLA) operating on vectors and matrices corresponds to the largest unit of vectors/matrices that can be operated upon during the execution of one instruction by the deep learning accelerator (DLA). During the execution of the instruction for a predefined operation on vector/matrix operands, elements of vector/matrix operands can be operated upon by the deep learning accelerator (DLA) in parallel to reduce execution time and/or energy consumption associated with memory/data access. The operations on vector/matrix operands of the granularity of the deep learning accelerator (DLA) can be used as building blocks to implement computations on vectors/matrices of larger sizes.

The implementation of a typical/practical artificial neural network (ANN) involves vector/matrix operands having sizes that are larger than the operation granularity of the deep learning accelerator (DLA). To implement such an artificial neural network (ANN) using the deep learning accelerator (DLA), computations involving the vector/matrix operands of large sizes can be broken down to the computations of vector/matrix operands of the granularity of the deep learning accelerator (DLA). The deep learning accelerator (DLA) can be programmed via instructions to carry out the computations involving large vector/matrix operands. For example, atomic computation capabilities of the deep learning accelerator (DLA) in manipulating vectors and matrices of the granularity of the deep learning accelerator (DLA) in response to instructions can be programmed to implement computations in an artificial neural network (ANN).

In some implementations, the deep learning accelerator (DLA) lacks some of the logic operation capabilities of a typical central processing unit (CPU). However, the deep learning accelerator (DLA) can be configured with sufficient logic units to process the input data provided to an artificial neural network (ANN) and generate the output of the artificial neural network (ANN) according to a set of instructions generated for the deep learning accelerator (DLA). Thus, the deep learning accelerator (DLA) can perform the computation of an artificial neural network (ANN) with little or no help from a central processing unit (CPU) or another processor. Optionally, a conventional general purpose processor can also be configured as part of the deep learning accelerator (DLA) to perform operations that cannot be implemented efficiently using the vector/matrix processing units of the deep learning accelerator (DLA), and/or that cannot be performed by the vector/matrix processing units of the deep learning accelerator (DLA).

A typical artificial neural network (ANN) can be described/specified in a standard format (e.g., open neural network exchange (ONNX)). A compiler can be used to convert the description of the artificial neural network (ANN) into a set of instructions for the deep learning accelerator (DLA) to perform calculations of the artificial neural network (ANN). The compiler can optimize the set of instructions to improve the performance of the deep learning accelerator (DLA) in implementing the artificial neural network (ANN).

The deep learning accelerator (DLA) can have local memory, such as registers, buffers and/or caches, configured to store vector/matrix operands and the results of vector/matrix operations. Intermediate results in the registers can be pipelined/shifted in the deep learning accelerator (DLA) as operands for subsequent vector/matrix operations to reduce time and energy consumption in accessing memory/data and thus speed up typical patterns of vector/matrix operations in implementing a typical artificial neural network (ANN). The capacity of registers, buffers and/or caches in the deep learning accelerator (DLA) is typically insufficient to hold the entire data set for implementing the computation of a typical artificial neural network (ANN). Thus, a random access memory coupled to the deep learning accelerator (DLA) is configured to provide an improved data storage capability for implementing a typical artificial neural network (ANN). For example, the deep learning accelerator (DLA) loads data and instructions from the random access memory and stores results back into the random access memory.

The communication bandwidth between the deep learning accelerator (DLA) and the random access memory is configured to optimize or maximize the utilization of the computation power of the deep learning accelerator (DLA). For example, high communication bandwidth can be provided between the deep learning accelerator (DLA) and the random access memory such that vector/matrix operands can be loaded from the random access memory into the deep learning accelerator (DLA) and results stored back into the random access memory in a time period that is approximately equal to the time for the deep learning accelerator (DLA) to perform the computations on the vector/matrix operands. The granularity of the deep learning accelerator (DLA) can be configured to increase the ratio between the amount of computations performed by the deep learning accelerator (DLA) and the size of the vector/matrix operands such that the data access traffic between the deep learning accelerator (DLA) and the random access memory can be reduced, which can reduce the requirement on the communication bandwidth between the deep learning accelerator (DLA) and the random access memory. Thus, the bottleneck in data/memory access can be reduced or eliminated.

Some video coding techniques are based on the analysis of a video using a deep learning technique. Deep learning-based video coding techniques can include coding schemes that are built primarily on deep neural networks (DNNs) and/or coding tools that use deep neural networks (DNNs) to generate models, predictions, parameters, and/or options for use in traditional coding schemes and/or with traditional coding tools.

For example, a pixel probability model can be computed/estimated using a deep neural network (DNN) to drive a deep learning-based coding scheme. For example, a deep neural network (DNN) can be used to perform or facilitate intra-picture prediction, inter-picture prediction, cross-channel prediction, probability distribution prediction, transform, post-loop filtering, in-loop filtering, down-sampling, up-sampling, encoding optimization, etc. The predictions/optimization can be used with traditional coding schemes and/or traditional coding tools.

At least one embodiment disclosed herein includes a surveillance camera that is configured with a deep learning accelerator (DLA) and random access memory to facilitate intelligent video/image processing using artificial neural networks (ANNs). The deep learning accelerator (DLA) can be provided via a removable media.

For example, an existing surveillance camera may not have a deep learning accelerator (DLA) but has a slot configured to receive a removable media to record video generated by the surveillance camera. Such a slot can be configured as part of a memory card reader of the surveillance camera; and such a removable media can be in the form of a memory card. The memory card can have a form factor and interface of secure digital (SD) cards, microsd cards, compactflash (CF) cards, memory stick cards, etc.

A replacement removable media can be configured with a deep learning accelerator (DLA) and random access memory to perform computations of artificial neural networks (ANNs) autonomously using models of artificial neural networks (ANNs) stored in the removable media. After the replacement removable media is inserted into the slot in the reader of the surveillance camera, the surveillance camera can store video/image data into the replacement removable media in a way same as storing video/image data into a conventional removable media.

In response to the video/image data being stored into the replacement removable media disclosed herein, the deep learning accelerator (DLA) automatically analyzes the video/image data to generate video analytics and/or inference results.

For example, the video analytics and/or inference results can be used to compress the video/image data using a deep learning-based video coding technique. The computation of the deep learning-based video coding can be performed within the removable media. Thus, the removable media can convert/compress an input video autonomously without help from the surveillance camera and/or a host system to which the camera may be connected.

For example, after the removable media device receives a high-resolution video, the deep learning accelerator (DLA) of the removable media performs an analysis of the video to generate video analytics with high accuracy. The video analytics can include pixel probability model, intra-picture prediction, inter-picture prediction, cross-channel prediction, probability distribution prediction, etc. Alternatively, or in combination, the video analytics can identify transform, post-loop filtering, in-loop filtering, down-sampling, up-sampling, encoding optimization, etc. The high-resolution video can be compressed through coding based on the video analytics to generate a compressed video as a replacement of the high-resolution video for storing the video in the device. Optionally, a set of configuration settings can be stored in the removable media to control aspects of the creation and storage of the compressed video. Such configuration settings can include input resolution, storage resolution, storage location, etc.

The removable media can be a memory card that can be plugged into a slot of a reader of memory cards of a host computer system. The memory card can be configured with a form factor and interface of secure digital (SD) cards, microsd cards, compactflash (CF) cards, memory stick cards, etc.

Alternatively, the removable media can be a network storage device that can be connected to a surveillance camera and/or a host computer system via a wired or wireless computer network connection.

Alternatively, the removable media can be a storage device that can be connected to a surveillance camera and/or a host computer system via a standardized port, such as a universal serial bus (USB) port.

Thus, in general, the removable media can be a solid state drive that can be connected to a host computer system via a port, such as a port to accept a universal serial bus (USB) device, a network storage device, or a memory card, or another type of removable data storage device.

For example, the removable media can be a plug and play device that can be plugged into a port or a slot of a running computer system and be recognized and configured by the running computer system on the fly for normal operations as a storage device without requiring the computer system to restart or reboot.

For example, the removable media can be dynamically added to a running computer system via a wired or wireless computer connection without requiring the computer system to restart or reboot.

In some simplified implementations, the removable media may be a data storage device that is not removable and/or may not be hot plugged into a running computer system in order to be configured for normal operations; and after the storage device is connected into the computer system (e.g., using a peripheral bus of the computer system, or a memory bus of the computer system), it may be necessary to restart the computer system to configure the storage device for normal operations in the computer system. In some implementations, the computer system is to be powered down in order to connect the storage device to the computer system.

For example, the removable media can include a host interface for a wired or a wireless connection to a host computer system using a wireless personal area network, a wireless local area network, a wired local area network, a universal serial bus (USB), etc. The host computer system can be a surveillance camera, a personal computer, a mobile computer, a smartphone, a personal media player, a set top box, a hub of internet of things (IoTs), and/or a server computer.

After the removable media is connected to the host computer system, the host computer system can send commands to the removable media to store data, such as a video file. In some instances, the video can be streamed to the removable media in an uncompressed format, or a compressed format. The deep learning accelerator in the storage device analyzes the video file/stream to generate video analytics, such as pixel probability model, intra-picture prediction, inter-picture prediction, cross-channel prediction, probability distribution prediction, transform, post-loop filtering, in-loop filtering, down-sampling, up-sampling, encoding optimization, etc. A video encoder of the removable media codes/encodes/compresses the video file based on the video analytics and generates a compressed video file that is stored in the removable media as a replacement of the video file/stream received from the host computer system.

Optionally, the removable media can perform real-time, on the fly compression when the host computer system streams the video to the removable media. While a subsequent portion of a video is being streamed into the removable media, the removable media provides a previously buffered portion of the video as input to an artificial neural network; and the deep learning accelerator of the removable media performs the computation of the artificial neural network to generate video analytics for the buffered portion; and the video encoder uses the video analytics to code/encode/compress of the buffered portion of the video stream on the fly while the streaming is in progress.

As an alternative to the deep learning-based compression of video data, or in combination, the deep learning accelerator (DLA) and the random access memory with an artificial neural network (ANN) provided in the surveillance camera (e.g., provided via the removable media) can be used for intelligent local processing of the image data captured by the surveillance camera.

For example, to reduce the data storage requirement and/or data communication traffic, the artificial neural network (ANN) implemented in the surveillance camera can convert the video/image data into inference results that are of interest to a specific application and thus eliminate the need to store and/or communicate most of, or all of, the video/image data captured by the image sensor of the surveillance camera.

For example, the artificial neural network (ANN) can be trained to recognize objects and/or events in the images that may be of interest in a surveillance application and convert the images into a description or identification of the objects and events appearing in the images captured by the surveillance camera. The description or identification of the objects and events can be used as a high level summary of the content in the images, which can be used as an input to the application running in a computer system that uses the surveillance camera as an input device. Such a computer system can be a mobile computer, a smart phone, a personal media player, a personal computer, a server computer, or a cluster of server computers. Such a high level summary of the content in the images, recognized using an artificial neural network, uses a significantly smaller amount of data storage capacity and/or data transmission bandwidth than the still images or video images that graphically present the corresponding objects and events.

Optionally, images of non-recognized objects and/or events in unusual/unexpected situations or sceneries can be transmitted to a separate computer system for further processing. For example, human operators may inspect the images to identify the objects and events captured in the images of the unusual/unexpected situations or sceneries; and the results can be used to further train the artificial neural network (ANN) (e.g., using a supervised machine learning technique) to improve its capability in identifying objects and events. Subsequently, the further trained artificial neural network (ANN) can be loaded into the surveillance camera to further reduce data that needs to be stored and/or processed outside of the surveillance camera.

Optionally, the surveillance camera can store for a predetermined period of time the image stream that has been converted into a summary or description. The image stream can be annotated with the summary or description and identifications of portions of images showing the objects and evens. Within the predetermined period of time, an application receiving the summary or description as input can select an object or event of interest and request the surveillance camera to transmit the relevant images of the object or event.

In some applications, the surveillance camera is configured (e.g., via the removable media) to monitor the image stream for objects and/or events satisfying predetermined selection criteria. When such objects and/or events are detected in the output of the artificial neural network (ANN), the surveillance camera selects representative portions from the image stream for storing and/or for uploading to a separate computer. Through the analysis performed by the artificial neural network (ANN), the information in the image stream can be compressed into a summary that includes the identifications of the objects of interest, representative images of the objects, and a description of activities of the objects in the scenery captured in the image stream. Information on recognized objects that are not of interest can be reduced and/or discard. Such a summary of the image stream can achieve a compression ratio better than conventional lossy or lossless image/video compression techniques; and in many applications of a surveillance camera, such a summary can be sufficient and/or more useful than the original image stream generated by the image sensor of the surveillance camera.

For example, instead of transmitting the image stream to a separate computer system for processing, the surveillance camera can provide a description of the content in the image stream to the computer system for processing. The representative images of the recognized images can be transmitted with the description, or provided when the computer system sends a request for such images. Further, the computer system may optionally request the surveillance camera to transmit a frame, or a segment of the image stream that contains an object or event of interest.

The description of the content in the image stream can be in the form of identifications of objects, events, features, classifications, locations in images, sizes in images, etc.

For example, a surveillance camera is configured with an image sensor to monitor the health condition of a user. An integrated circuit device having a deep learning accelerator and random access memory is configured in the surveillance camera to process the sensor data locally. Images of the user determined to be not associated with health concerns can be discarded automatically to reduce the need to store a large amount of raw image data and to protect the privacy of the user.

The surveillance camera can be customized for a particular application of intelligent monitoring by storing a model of an artificial neural network (ANN) executable by the deep learning accelerator (DLA). For example, the model can be converted from a description of the artificial neural network (ANN) using a compiler; and the model includes weight/kernel matrices of the artificial neural network (ANN) and instructions with matrix operands, executable by the deep learning accelerator (DLA) to implement the computation of the artificial neural network (ANN) based on the weight/kernel matrices.

For example, a surveillance camera can be configured in a health care facility to monitor the conditions of a patients. Different patients can have different health issues that require the monitoring for the detection of the onset of different symptoms. Thus, a surveillance camera can be customized for the patient currently being monitored by installing a model of an artificial neural network (ANN) trained for the detection of symptoms relevant to the patient.

After the surveillance camera is customized through storing the model in the random access memory to perform the computations of the artificial neural network (ANN), the raw image data generated by the image sensor in the surveillance camera is provided as input to the artificial neural network (ANN); and the outputs of the artificial neural network (ANN) can be used to generate alerts, to selectively retain and/or report sensor data, and/or be provided as the primary output of the surveillance camera.

For example, the surveillance camera can include a wireless transceiver (e.g., a communication device for a wireless personal area network, such as a bluetooth transceiver, or a communication device for a wireless local area network, such as a wi-fi transceiver). Through a wireless connection, the output of the artificial neural network (ANN) can be reported to a separate computer system, such as a smartphone, a personal media player, a mobile computer, a personal computer, a hub of internet of things (IoTs), and/or a server computer.

Alternatively, the surveillance camera can have a port for a wired connection to a separate computer system to report the output of the artificial neural network (ANN) or download the outputs stored in the surveillance camera over a period of time.

For example, the artificial neural network (ANN) can be trained to classify whether an image is of interest to a specific application. The output of the artificial neural network (ANN) can be used to selectively store image data for subsequent analysis and/or downloading.

For example, the surveillance camera can provide, to a computer system and without assistance from the computer system, intelligent outputs that are generated locally in the surveillance camera using the artificial neural network (ANN). For example, the surveillance camera can be used to monitor for a health related event and generate an alert when such an event is detected. For example, the surveillance camera can be used to monitor for indications related to the diagnosis of a health problem and record occurrences of such indications and/or associated data for further analysis. For example, the surveillance camera can be used to monitor the user for a fall and generate a call for assistance when detecting that the user is falling. For example, the surveillance camera can be used to detect the appearance of an object in the surrounding of the user of the surveillance camera, and provide an identification of the object for further processing. For example, the surveillance camera can be used to detect a gesture of the user and provide the identification of the gesture to a separate computer (e.g., a smartphone, a game console, a personal media player, a personal computer, a set top box), to control an operation in the separate computer.

The random access memory coupled with the deep learning accelerator can include a portion configured to store input to the artificial neural network (ANN) and another portion configured to store output from the artificial neural network (ANN). The input video data received from the host computer system can be stored in a cyclic way in the input portion of the random access memory. Thus, the input video data for the latest period of the buffering a video stream in the storage device can be found in the input portion of the random access memory for analysis by the deep learning accelerator according to the artificial neural network (ANN) and for encoding by the video encoder. The deep learning accelerator (DLA) can convert in real time, the input video audio data in the input portion into video analytics and/or inference results stored in the output portion of the random access memory. A video encoder can be configured to use video analytics and/or inference results stored in the output portion of the random access memory to compress the input video data stored in the input portion of the random access memory. The compressed video can include a description of the content in the video as recognized by the artificial neural network (ANN) and can be stored in the random access memory or another storage media according to a set of configuration parameters.

For example, a stream of input video data to the artificial neural network (ANN) can be analyzed by the artificial neural network (ANN) into identify segments associated with different scenes depicted in the video stream. Each video segment can be configured to be compressed as a unit. The length of a video segment can be limited by a predetermined number of frames. Further, each video segment can be provided as a set of input to the artificial neural network (ANN) during a time slot. While the deep learning accelerator (DLA) is computing the video analytics from the current set of input, the next video segment can be stored into the random access memory as the next input to the artificial neural network (ANN); and concurrently, the output generated for the previous video segment can be retrieved from the random access memory for the coding/encoding/compression of the previous video segment. The input region of the random access memory can accommodate the storage of multiple video segments at the same time; and after the previous video segment has been encoded and stored, a new video segment can be stored/streamed into the area where the previous video segment is stored.

Thus, the task of compressing a video stream using an artificial neural network (ANN) can be added to a surveillance camera by inserting a removable media according to embodiments disclosed herein. The computation of the artificial neural network (ANN) can be performed locally on the removable media to reduce data storage requirement and/or to reduce computation workload on the surveillance camera and/or the host computer system that uses the surveillance camera.

Further, neuromorphic memory can be used to implement the computations of matrix/vector multiplication and summation to reduce power consumption of the deep learning accelerator (DLA).

For example, neuromorphic memory can be implemented using a crossbar array of memristors that are configured to perform the multiply-and-accumulate (MAC) operations via analog circuitry. Electric currents going through the wordlines through a set of memristors in the crossbar array to a bitline are summed in the bitline, which corresponds to the accumulation operation. The electric currents correspond to the multiplication of the voltages applied on the wordlines and parameters associated with the resistances of the memristors, which corresponds to the multiplication operations. The current in the bitline can be compared with a threshold to determine whether a neuron represented by the bitline is activated under the current input. An array of memristors can be connected to the bitlines respectively and programmed to have thresholds corresponding to the activation level thresholds of the neurons. A current detector can be configured for each memristor connected to the output of a bitline to determine whether the level of electric current in the bitline corresponding to a level that exceeds the threshold of the memristor.

FIG. 1 shows an integrated circuit device (101) having a deep learning accelerator (103) and random access memory (105) configured according to one embodiment.

The deep learning accelerator (103) in FIG. 1 includes processing units (111), a control unit (113), and local memory (115). When vector and matrix operands are in the local memory (115), the control unit (113) can use the processing units (111) to perform vector and matrix operations in accordance with instructions. Further, the control unit (113) can load instructions and operands from the random access memory (105) through a memory interface (117) and a high speed/bandwidth connection (119).

The integrated circuit device (101) is configured to be enclosed within an integrated circuit package with pins or contacts for a memory controller interface (107).

The memory controller interface (107) is configured to support a standard memory access protocol such that the integrated circuit device (101) appears to a typical memory controller in a way same as a conventional random access memory device having no deep learning accelerator (DLA) (103). For example, a memory controller external to the integrated circuit device (101) can access, using a standard memory access protocol through the memory controller interface (107), the random access memory (105) in the integrated circuit device (101).

The integrated circuit device (101) is configured with a high bandwidth connection (119) between the random access memory (105) and the deep learning accelerator (DLA) (103) that are enclosed within the integrated circuit device (101). The bandwidth of the connection (119) is higher than the bandwidth of the connection (109) between the random access memory (105) and the memory controller interface (107).

In one embodiment, both the memory controller interface (107) and the memory interface (117) are configured to access the random access memory (105) via a same set of buses or wires. Thus, the bandwidth to access the random access memory (105) is shared between the memory interface (117) and the memory controller interface (107). Alternatively, the memory controller interface (107) and the memory interface (117) are configured to access the random access memory (105) via separate sets of buses or wires. Optionally, the random access memory (105) can include multiple sections that can be accessed concurrently via the connection (119). For example, when the memory interface (117) is accessing a section of the random access memory (105), the memory control interface (107) can concurrently access another section of the random access memory (105). For example, the different sections can be configured on different integrated circuit dies and/or different planes/banks of memory cells; and the different sections can be accessed in parallel to increase throughput in accessing the random access memory (105). For example, the memory controller interface (107) is configured to access one data unit of a predetermined size at a time; and the memory interface (117) is configured to access multiple data units, each of the same predetermined size, at a time.

In one embodiment, the random access memory (105) and the integrated circuit device (101) are configured on different integrated circuit dies configured within a same integrated circuit package. Further, the random access memory (105) can be configured on one or more integrated circuit dies that allows parallel access of multiple data elements concurrently.

In some implementations, the number of data elements of a vector or matrix that can be accessed in parallel over the connection (119) corresponds to the granularity of the deep learning accelerator (DLA) operating on vectors or matrices. For example, when the processing units (111) can operate on a number of vector/matrix elements in parallel, the connection (119) is configured to load or store the same number, or multiples of the number, of elements via the connection (119) in parallel.

Optionally, the data access speed of the connection (119) can be configured based on the processing speed of the deep learning accelerator (DLA) (103). For example, after an amount of data and instructions have been loaded into the local memory (115), the control unit (113) can execute an instruction to operate on the data using the processing units (111) to generate output. Within the time period of processing to generate the output, the access bandwidth of the connection (119) allows the same amount of data and instructions to be loaded into the local memory (115) for the next operation and the same amount of output to be stored back to the random access memory (105). For example, while the control unit (113) is using a portion of the local memory (115) to process data and generate output, the memory interface (117) can offload the output of a prior operation into the random access memory (105) from, and load operand data and instructions into, another portion of the local memory (115). Thus, the utilization and performance of the deep learning accelerator (DLA) are not restricted or reduced by the bandwidth of the connection (119).

The random access memory (105) can be used to store the model data of an artificial neural network (ANN) and to buffer input data for the artificial neural network (ANN). The model data does not change frequently. The model data can include the output generated by a compiler for the deep learning accelerator (DLA) to implement the artificial neural network (ANN). The model data typically includes matrices used in the description of the artificial neural network (ANN) and instructions generated for the deep learning accelerator (DLA) (103) to perform vector/matrix operations of the artificial neural network (ANN) based on vector/matrix operations of the granularity of the deep learning accelerator (DLA) (103). The instructions operate not only on the vector/matrix operations of the artificial neural network (ANN), but also on the input data for the artificial neural network (ANN).

In one embodiment, when the input data is loaded or updated in the random access memory (105), the control unit (113) of the deep learning accelerator (DLA) (103) can automatically execute the instructions for the artificial neural network (ANN) to generate an output of the artificial neural network (ANN). The output is stored into a predefined region in the random access memory (105). The deep learning accelerator (DLA) (103) can execute the instructions without help from a central processing unit (CPU). Thus, communications for the coordination between the deep learning accelerator (DLA) (103) and a processor outside of the integrated circuit device (101) (e.g., a central processing unit (CPU)) can be reduced or eliminated.

Optionally, the logic circuit of the deep learning accelerator (DLA) (103) can be implemented via complementary metal oxide semiconductor (CMOS). For example, the technique of CMOS under the array (CUA) of memory cells of the random access memory (105) can be used to implement the logic circuit of the deep learning accelerator (DLA) (103), including the processing units (111) and the control unit (113). Alternatively, the technique of CMOS in the array of memory cells of the random access memory (105) can be used to implement the logic circuit of the deep learning accelerator (DLA) (103).

In some implementations, the deep learning accelerator (DLA) (103) and the random access memory (105) can be implemented on separate integrated circuit dies and connected using through-silicon vias (TSV) for increased data bandwidth between the deep learning accelerator (DLA) (103) and the random access memory (105). For example, the deep learning accelerator (DLA) (103) can be formed on an integrated circuit die of a field-programmable gate array (FPGA) or application specific integrated circuit (ASIC).

Alternatively, the deep learning accelerator (DLA) (103) and the random access memory (105) can be configured in separate integrated circuit packages and connected via multiple point-to-point connections on a printed circuit board (PCB) for parallel communications and thus increased data transfer bandwidth.

The random access memory (105) can be volatile memory or non-volatile memory, or a combination of volatile memory and non-volatile memory. Examples of non-volatile memory include flash memory, memory cells formed based on negative-and (NAND) logic gates, negative-or (NOR) logic gates, phase-change memory (PCM), magnetic memory (MRAM), resistive random-access memory, cross point storage and memory devices. A cross point memory device can use transistor-less memory elements, each of which has a memory cell and a selector that are stacked together as a column. Memory element columns are connected via two layers of wires running in perpendicular directions, where wires of one layer run in one direction in the layer that is located above the memory element columns, and wires of the other layer run in another direction and are located below the memory element columns. Each memory element can be individually selected at a cross point of one wire on each of the two layers. Cross point memory devices are fast and non-volatile and can be used as a unified memory pool for processing and storage. Further examples of non-volatile memory include read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM) and electronically erasable programmable read-only memory (EEPROM) memory, etc. Examples of volatile memory include dynamic random-access memory (DRAM) and static random-access memory (SRAM).

For example, non-volatile memory can be configured to implement at least a portion of the random access memory (105). The non-volatile memory in the random access memory (105) can be used to store the model data of an artificial neural network (ANN). Thus, after the integrated circuit device (101) is powered off and restarts, it is not necessary to reload the model data of the artificial neural network (ANN) into the integrated circuit device (101). Further, the non-volatile memory can be programmable/rewritable. Thus, the model data of the artificial neural network (ANN) in the integrated circuit device (101) can be updated or replaced to implement an update artificial neural network (ANN), or another artificial neural network (ANN).

The processing units (111) of the deep learning accelerator (DLA) (103) can include vector-vector units, matrix-vector units, and/or matrix-matrix units. Examples of units configured to perform for vector-vector operations, matrix-vector operations, and matrix-matrix operations are discussed below in connection with FIGS. 2-4.

FIG. 2 shows a processing unit (121) configured to perform matrix-matrix operations according to one embodiment. For example, the matrix-matrix unit (121) of FIG. 2 can be used as one of the processing units (111) of the deep learning accelerator (DLA) (103) of FIG. 1.

In FIG. 2, the matrix-matrix unit (121) includes multiple kernel buffers (131 to 133) and multiple the maps banks (151 to 153). Each of the maps banks (151 to 153) stores one vector of a matrix operand that has multiple vectors stored in the maps banks (151 to 153) respectively; and each of the kernel buffers (131 to 133) stores one vector of another matrix operand that has multiple vectors stored in the kernel buffers (131 to 133) respectively. The matrix-matrix unit (121) is configured to perform multiplication and accumulation operations on the elements of the two matrix operands, using multiple matrix-vector units (141 to 143) that operate in parallel.

A crossbar (123) connects the maps banks (151 to 153) to the matrix-vector units (141 to 143). The same matrix operand stored in the maps bank (151 to 153) is provided via the crossbar (123) to each of the matrix-vector units (141 to 143); and the matrix-vector units (141 to 143) receives data elements from the maps banks (151 to 153) in parallel. Each of the kernel buffers (131 to 133) is connected to a respective one in the matrix-vector units (141 to 143) and provides a vector operand to the respective matrix-vector unit. The matrix-vector units (141 to 143) operate concurrently to compute the operation of the same matrix operand, stored in the maps banks (151 to 153) multiplied by the corresponding vectors stored in the kernel buffers (131 to 133). For example, the matrix-vector unit (141) performs the multiplication operation on the matrix operand stored in the maps banks (151 to 153) and the vector operand stored in the kernel buffer (131), while the matrix-vector unit (143) is concurrently performing the multiplication operation on the matrix operand stored in the maps banks (151 to 153) and the vector operand stored in the kernel buffer (133).

Each of the matrix-vector units (141 to 143) in FIG. 2 can be implemented in a way as illustrated in FIG. 3.

FIG. 3 shows a processing unit (141) configured to perform matrix-vector operations according to one embodiment. For example, the matrix-vector unit (141) of FIG. 3 can be used as any of the matrix-vector units in the matrix-matrix unit (121) of FIG. 2.

In FIG. 3, each of the maps banks (151 to 153) stores one vector of a matrix operand that has multiple vectors stored in the maps banks (151 to 153) respectively, in a way similar to the maps banks (151 to 153) of FIG. 2. The crossbar (123) in FIG. 3 provides the vectors from the maps banks (151) to the vector-vector units (161 to 163) respectively. A same vector stored in the kernel buffer (131) is provided to the vector-vector units (161 to 163).

The vector-vector units (161 to 163) operate concurrently to compute the operation of the corresponding vector operands, stored in the maps banks (151 to 153) respectively, multiplied by the same vector operand that is stored in the kernel buffer (131). For example, the vector-vector unit (161) performs the multiplication operation on the vector operand stored in the maps bank (151) and the vector operand stored in the kernel buffer (131), while the vector-vector unit (163) is concurrently performing the multiplication operation on the vector operand stored in the maps bank (153) and the vector operand stored in the kernel buffer (131).

When the matrix-vector unit (141) of FIG. 3 is implemented in a matrix-matrix unit (121) of FIG. 2, the matrix-vector unit (141) can use the maps banks (151 to 153), the crossbar (123) and the kernel buffer (131) of the matrix-matrix unit (121).

Each of the vector-vector units (161 to 163) in FIG. 3 can be implemented in a way as illustrated in FIG. 4.

FIG. 4 shows a processing unit (161) configured to perform vector-vector operations according to one embodiment. For example, the vector-vector unit (161) of FIG. 4 can be used as any of the vector-vector units in the matrix-vector unit (141) of FIG. 3.

In FIG. 4, the vector-vector unit (161) has multiple multiply-accumulate (MAC) units (171 to 173). Each of the multiply-accumulate (MAC) units (171 to 173) can receive two numbers as operands, perform multiplication of the two numbers, and add the result of the multiplication to a sum maintained in the multiply-accumulate (MAC) unit.

Each of the vector buffers (181 and 183) stores a list of numbers. A pair of numbers, each from one of the vector buffers (181 and 183), can be provided to each of the multiply-accumulate (MAC) units (171 to 173) as input. The multiply-accumulate (MAC) units (171 to 173) can receive multiple pairs of numbers from the vector buffers (181 and 183) in parallel and perform the multiply-accumulate (MAC) operations in parallel. The outputs from the multiply-accumulate (MAC) units (171 to 173) are stored into the shift register (175); and an accumulator (177) computes the sum of the results in the shift register (175).

When the vector-vector unit (161) of FIG. 4 is implemented in a matrix-vector unit (141) of FIG. 3, the vector-vector unit (161) can use a maps bank (e.g., 151 or 153) as one vector buffer (181), and the kernel buffer (131) of the matrix-vector unit (141) as another vector buffer (183).

The vector buffers (181 and 183) can have a same length to store the same number/count of data elements. The length can be equal to, or the multiple of, the count of multiply-accumulate (MAC) units (171 to 173) in the vector-vector unit (161). When the length of the vector buffers (181 and 183) is the multiple of the count of multiply-accumulate (MAC) units (171 to 173), a number of pairs of inputs, equal to the count of the multiply-accumulate (MAC) units (171 to 173), can be provided from the vector buffers (181 and 183) as inputs to the multiply-accumulate (MAC) units (171 to 173) in each iteration; and the vector buffers (181 and 183) feed their elements into the multiply-accumulate (MAC) units (171 to 173) through multiple iterations.

In one embodiment, the communication bandwidth of the connection (119) between the deep learning accelerator (DLA) (103) and the random access memory (105) is sufficient for the matrix-matrix unit (121) to use portions of the random access memory (105) as the maps banks (151 to 153) and the kernel buffers (131 to 133).

In another embodiment, the maps banks (151 to 153) and the kernel buffers (131 to 133) are implemented in a portion of the local memory (115) of the deep learning accelerator (DLA) (103). The communication bandwidth of the connection (119) between the deep learning accelerator (DLA) (103) and the random access memory (105) is sufficient to load, into another portion of the local memory (115), matrix operands of the next operation cycle of the matrix-matrix unit (121), while the matrix-matrix unit (121) is performing the computation in the current operation cycle using the maps banks (151 to 153) and the kernel buffers (131 to 133) implemented in a different portion of the local memory (115) of the deep learning accelerator (DLA) (103).

FIG. 5 shows a deep learning accelerator and random access memory configured to autonomously apply inputs to a trained artificial neural network according to one embodiment.

An artificial neural network (ANN) (201) that has been trained through machine learning (e.g., deep learning) can be described in a standard format (e.g., open neural network exchange (ONNX)). The description of the trained artificial neural network (ANN) (201) in the standard format identifies the properties of the artificial neurons and their connectivity.

In FIG. 5, a deep learning accelerator (DLA) compiler (203) converts trained artificial neural network (ANN) (201) by generating instructions (205) for a deep learning accelerator (DLA) (103) and matrices (207) corresponding to the properties of the artificial neurons and their connectivity. The instructions (205) and the matrices (207) generated by the DLA compiler (203) from the trained artificial neural network (ANN) (201) can be stored in random access memory (105) for the deep learning accelerator (DLA) (103).

For example, the random access memory (105) and the deep learning accelerator (DLA) (103) can be connected via a high bandwidth connection (119) in a way as in the integrated circuit device (101) of FIG. 1. The autonomous computation of FIG. 5 based on the instructions (205) and the matrices (207) can be implemented in the integrated circuit device (101) of FIG. 1. Alternatively, the random access memory (105) and the deep learning accelerator (DLA) (103) can be configured on a printed circuit board with multiple point to point serial buses running in parallel to implement the connection (119).

In FIG. 5, after the results of the DLA compiler (203) are stored in the random access memory (105), the application of the trained artificial neural network (ANN) (201) to process an input (211) to the trained artificial neural network (ANN) (201) to generate the corresponding output (213) of the trained artificial neural network (ANN) (201) can be triggered by the presence of the input (211) in the random access memory (105), or another indication provided in the random access memory (105).

In response, the deep learning accelerator (DLA) (103) executes the instructions (205) to combine the input (211) and the matrices (207). The execution of the instructions (205) can include the generation of maps matrices for the maps banks (151 to 153) of one or more matrix-matrix units (e.g., 121) of the deep learning accelerator (DLA) (103).

In some embodiments, the inputs to ANN (211) is in the form of an initial maps matrix. Portions of the initial maps matrix can be retrieved from the random access memory (105) as the matrix operand stored in the maps banks (151 to 153) of a matrix-matrix unit (121). Alternatively, the DLA instructions (205) also include instructions for the deep learning accelerator (DLA) (103) to generate the initial maps matrix from the input (211).

According to the DLA instructions (205), the deep learning accelerator (DLA) (103) loads matrix operands into the kernel buffers (131 to 133) and maps banks (151 to 153) of its matrix-matrix unit (121). The matrix-matrix unit (121) performs the matrix computation on the matrix operands. For example, the DLA instructions (205) break down matrix computations of the trained artificial neural network (ANN) (201) according to the computation granularity of the deep learning accelerator (DLA) (103) (e.g., the sizes/dimensions of matrices that loaded as matrix operands in the matrix-matrix unit (121)) and applies the input feature maps to the kernel of a layer of artificial neurons to generate output as the input for the next layer of artificial neurons.

Upon completion of the computation of the trained artificial neural network (ANN) (201) performed according to the instructions (205), the deep learning accelerator (DLA) (103) stores the output (213) of the artificial neural network (ANN) (201) at a pre-defined location in the random access memory (105), or at a location specified in an indication provided in the random access memory (105) to trigger the computation.

When the technique of FIG. 5 is implemented in the integrated circuit device (101) of FIG. 1, an external device connected to the memory controller interface (107) can write the input (211) into the random access memory (105) and trigger the autonomous computation of applying the input (211) to the trained artificial neural network (ANN) (201) by the deep learning accelerator (DLA) (103). After a period of time, the output (213) is available in the random access memory (105); and the external device can read the output (213) via the memory controller interface (107) of the integrated circuit device (101).

For example, a predefined location in the random access memory (105) can be configured to store an indication to trigger the autonomous execution of the instructions (205) by the deep learning accelerator (DLA) (103). The indication can optionally include a location of the input (211) within the random access memory (105). Thus, during the autonomous execution of the instructions (205) to process the input (211), the external device can retrieve the output generated during a previous run of the instructions (205), and/or store another set of input for the next run of the instructions (205).

Optionally, a further predefined location in the random access memory (105) can be configured to store an indication of the progress status of the current run of the instructions (205). Further, the indication can include a prediction of the completion time of the current run of the instructions (205) (e.g., estimated based on a prior run of the instructions (205)). Thus, the external device can check the completion status at a suitable time window to retrieve the output (213).

In some embodiments, the random access memory (105) is configured with sufficient capacity to store multiple sets of inputs (e.g., 211) and outputs (e.g., 213). Each set can be configured in a predetermined slot/area in the random access memory (105).

The deep learning accelerator (DLA) (103) can execute the instructions (205) autonomously to generate the output (213) from the input (211) according to matrices (207) stored in the random access memory (105) without helps from a processor or device that is located outside of the integrated circuit device (101).

In a method according to one embodiment, random access memory (105) of a computing device (e.g., 101) can be accessed using an interface (107) of the computing device (e.g., 101) to a memory controller. The computing device (e.g., 101) can have processing units (e.g., 111) configured to perform at least computations on matrix operands, such as a matrix operand stored in maps banks (151 to 153) and a matrix operand stored in kernel buffers (131 to 133).

For example, the computing device (e.g., 101) can be enclosed within an integrated circuit package; and a set of connections can connect the interface (107) to the memory controller that is located outside of the integrated circuit package.

Instructions (205) executable by the processing units (e.g., 111) can be written into the random access memory (105) through the interface (107).

Matrices (207) of an artificial neural network (201) can be written into the random access memory (105) through the interface (107). The matrices (207) identify the property and/or state of the artificial neural network (201).

Optionally, at least a portion of the random access memory (105) is non-volatile and configured to store the instructions (205) and the matrices (207) of the artificial neural network (201).

First input (211) to the artificial neural network can be written into the random access memory (105) through the interface (107).

An indication is provided in the random access memory (105) to cause the processing units (111) to start execution of the instructions (205). In response to the indication, the processing units (111) execute the instructions to combine the first input (211) with the matrices (207) of the artificial neural network (201) to generate first output (213) from the artificial neural network (201) and store the first output (213) in the random access memory (105).

For example, the indication can be an address of the first input (211) in the random access memory (105); and the indication can be stored a predetermined location in the random access memory (105) to cause the initiation of the execution of the instructions (205) for the input (211) identified by the address. Optionally, the indication can also include an address for storing the output (213).

The first output (213) can be read, through the interface (107), from the random access memory (105).

For example, the computing device (e.g., 101) can have a deep learning accelerator (103) formed on a first integrated circuit die and the random access memory (105) formed on one or more second integrated circuit dies. The connection (119) between the first integrated circuit die and the one or more second integrated circuit dies can include through-silicon vias (TSVs) to provide high bandwidth for memory access.

For example, a description of the artificial neural network (201) can be converted using a compiler (203) into the instructions (205) and the matrices (207). The combination of the instructions (205) and the matrices (207) stored in the random access memory (105) and the deep learning accelerator (103) provides an autonomous implementation of the artificial neural network (201) that can automatically convert input (211) to the artificial neural network (201) to its output (213).

For example, during a time period in which the deep learning accelerator (103) executes the instructions (205) to generate the first output (213) from the first input (211) according to the matrices (207) of the artificial neural network (201), the second input to artificial neural network (201) can be written into the random access memory (105) through the interface (107) at an alternative location. After the first output (213) is stored in the random access memory (105), an indication can be provided in the random access memory to cause the deep learning accelerator (103) to again start the execution of the instructions and generate second output from the second input.

During the time period in which the deep learning accelerator (103) executes the instructions (205) to generate the second output from the second input according to the matrices (207) of the artificial neural network (201), the first output (213) can be read from the random access memory (105) through the interface (107); and a further input can be written into the random access memory to replace the first input (211), or written at a different location. The process can be repeated for a sequence of inputs.

The deep learning accelerator (103) can include at least one matrix-matrix unit (121) that can execute an instruction on two matrix operands. The two matrix operands can be a first matrix and a second matrix. Each of two matrices has a plurality of vectors. The matrix-matrix unit (121) can include a plurality of matrix-vector units (141 to 143) configured to operate in parallel. Each of the matrix-vector units (141 to 143) are configured to operate, in parallel with other matrix-vector units, on the first matrix and one vector from second matrix. Further, each of the matrix-vector units (141 to 143) can have a plurality of vector-vector units (161 to 163) configured to operate in parallel. Each of the vector-vector units (161 to 163) is configured to operate, in parallel with other vector-vector units, on a vector from the first matrix and a common vector operand of the corresponding matrix-vector unit. Further, each of the vector-vector units (161 to 163) can have a plurality of multiply-accumulate units (171 to 173) configured to operate in parallel.

The deep learning accelerator (103) can have local memory (115) and a control unit (113) in addition to the processing units (111). The control unit (113) can load instructions (205) and matrix operands (e.g., 207) from the random access memory (105) for execution by the processing units (111). The local memory can cache matrix operands used by the matrix-matrix unit. The connection (119) can be configured with a bandwidth sufficient to load a set of matrix operands from the random access memory (105) to the local memory (115) during a time period in which the matrix-matrix unit performs operations on two other matrix operands. Further, during the time period, the bandwidth is sufficient to store a result, generated by the matrix-matrix unit (121) in a prior instruction execution, from the local memory (115) to the random access memory (105).

The deep learning accelerator (103) and the random access memory (105) can be configured in a data storage device, such as a removable media, to calculate video analytics for compressing video data. For example, the removable media configured in a surveillance camera can calculate and use the video analytics to compress the video captured by its image sensor using a deep learning-based coding technique. Alternatively, or in combination, the video analytics can include inference results of identifications of items and/or events of interest such that the input video is compressed as a description of content recognized by an artificial neural network in the video and optionally representative images/clips of the recognized items and/or events.

For example, the data storage device (e.g., in the form of a removable media) can receive a video stream from the image sensor of the surveillance camera for recording. In response, the data storage device automatically generates a compressed video file storing the video stream using a deep learning-based video coding technique and/or as a description of recognized content in the video stream.

For example, a set of configuration parameters can be stored into the data storage device to control aspects of the compress of video files/streams provided to the data storage device. The configuration parameters can include identifications of attributes of the video files/streams to be compressed for storing in the data storage device, such as the format and resolution of the input video files/streams, the resolution of the compressed video file, the location in the data storage device to store the compressed video file, etc.

After the configuration parameters are stored in the data storage device, the data storage device can automatically convert a video file/stream received from the image sensor and/or a controller of the surveillance camera into a compressed video file using a deep learning-based video coding technique.

For example, the deep learning accelerator (103) executes the instructions (205) to perform the computation of the artificial neural network (201) that receives the video file/stream as the input (211) and generating the video analytics as the output (213); and a video encoder uses the video analytics to compress the video file/stream and generate a compressed video file that is stored in the data storage device. Subsequently, a computer system may retrieve the compressed video file for playing back the video content, or request the data storage device to decompress the video file for streaming from the data storage device in another format for playback.

For example, the data storage device in a form of a removable media can have an interface to a reader (e.g., memory card reader) or a port (e.g., USB port). Alternatively, the data storage device can have a transceiver or a host interface for a wired or wireless communication connection to a separate computer system such as a surveillance camera, a personal computer, a set top box, a hub of internet of things (IoT), a server computer, a smartphone, a personal medial player, a mobile computer, a tablet computer, etc. The computer system may store a video into the data storage device, which uses a deep learning-based video coding technique to compress it for storage in the device.

The video compression capability of the data storage device can be customized, updated, and/or upgraded via receiving, through the transceiver or host interface, and storing into the random access memory (105), the matrices (207) and instructions (205) of an artificial neural network (201).

The artificial neural network (201), implemented via the deep learning accelerator (103) executing the instructions (205), provides analytics for the compression of the video received in the transceiver or host interface for storing in the data storage device. The compression improves the capability of the data storage device in storing video content, reduces the communication bandwidth to transmit the video content from the data storage device, and/or reduces the computation workloads of the computer system in which the data storage device is installed.

Alternatively, or in combination, the deep learning accelerator (103) and the random access memory (105) configured in the data storage device can be configured to convert video/image data into a description of content recognized by an artificial neural network from the video/image data. For example, the surveillance camera having the data storage device can be used to monitor the condition and/or surrounding of a user or location to generate alerts and/or selectively store image data based on the description.

For example, the data storage device can store the description with representative images/clips of recognized items and/or events as a version of the video stream from the image sensor of the surveillance camera. The surveillance camera can provide the version of the video stream to a computer system to implement a specific surveillance application. The description can provide identifications of recognized items or events that are identified by an artificial neural network (201). The separate computer system further processes the identifications to generate an alert, to provide a display, to selective request image data from the surveillance camera, and/or to selectively store image data.

The surveillance camera is customizable, updatable, and/or upgradable via receiving and storing into the random access memory (105) the matrices (207) and instructions (205) of an artificial neural network (201).

The artificial neural network (201), implemented via the deep learning accelerator (103) executing the instructions (205), converts the image stream from an image sensor into inference results. The conversion improves the quality of outputs of the surveillance camera, reduces the communication bandwidth requirement for the connection to the computer system, and/or reduces the computation workloads of the computer system.

FIG. 6 illustrates a technique to upgrade a surveillance camera (231) using a removable media (191) according to one embodiment.

The surveillance camera (231) may not have the capability to perform the computation of an artificial neural network (201) when the removable media A (192) is in the surveillance camera (231).

However, the surveillance camera (231) is configured to record a video in the removable media A (192).

For example, the surveillance camera (231) has an image sensor (233) that can generate a video stream of a scene as seen through a lens (239) of the surveillance camera (231).

Examples of image sensors include a charge coupled device (CCD) image sensor, and a complementary metal oxide semiconductor (CMOS) image sensor. The image sensor (233) can be formed on an integrated circuit die.

A controller (235) of the surveillance camera (231) can control the operations of the surveillance camera (231) in response to commands received in a communication interface (237) over a wired or wireless connection (228) to a computer system (223).

For example, the controller (235) can record the video stream into the removable media (192) in response to a command from the computer system (223) and provide the video stream from the removable media A (192) to the computer system (223) in response to another command from the computer system (223).

In FIG. 6, a removable media B (191) is configured with a deep learning accelerator (DLA) (103) and random access memory (105). When the removable media A (192) is replaced with the removable media B (191), the surveillance camera (231) is upgraded to have the capability to perform the computation of an artificial neural network (201).

Once the removable media B (191) is in the surveillance camera (231), the controller (235) can record a video/image stream generated by the image sensor (233) into the removable media B (191). In response to recording the video/image stream in the removable media (191), the deep learning accelerator (103) executes instructions (205) stored in the random access memory (105) to perform the computations of the artificial neural network (201) using the matrices (207) stored in the random access memory (105). The output of the artificial neural network (201) can be used to generate intelligent output usable by the computer system (223). The output can include a compressed video coded using a deep learning-based coding technique, and/or a description of content recognized by the artificial neural network (201) from the video.

For example, the removable media (191) illustrated in FIGS. 7-9 can be used as the removable media B (191) to upgrade the surveillance camera (231).

FIGS. 7-9 illustrate removable media (191) having a deep learning accelerator (103) and random access memory (105) configured according to some embodiments.

A removable media (191) in FIG. 7, 8, or 9 includes a video encoder (215). The video encoder (215) can be implemented using software executed by a general purpose processor, or using an encoder logic circuit. In some embodiments, an encoding-specific logic circuit is used to accelerate a portion of the encoding operations; and a remaining portion of the encoding operations is performed by executing a set of software instructions. Thus, the video encoders (215) in FIG. 7, 8, or 9 are not limited to a specific hardware/software implementation.

The operations of the video encoder (215) are based at least in part on the video analytics (102) in the output (213) of the artificial neural network (201) that receives the video (104) as input (211).

The input video (104) can be initially received from an image sensor (233) of a surveillance camera (231) in an uncompressed format, in a format compressed using a lossless compression technique, or in a format compressed using a lossy compression technique. Configuration parameters (221) are stored into the random access memory (105) to identify the format of the input video (104) and/or desired compression operations to be performed on the input video (104).

When the input video (104) is initially in a compressed format, the removable media (191) uses a corresponding decoder to generate the video content in an uncompressed format where the image attributes of individual pixels in individual frames are explicitly specified. When a video is in a compressed format, at least some pixels of some frames in the video are implicitly specified using data associated with other pixels and/or other frames. The decoder can be implemented in the removable media (191) using hardware and/or software.

In some implementations, the decoder decompresses the input video (104) on the fly when the input video (104) is stored into the random access memory as the input (211) to the artificial neural network (201), or when the input video (104) is retrieved from the random access memory as the input (211) to the artificial neural network (201).

The deep learning accelerator (103) executes the instructions (205) to generate the video analytics (102) of the input video (104).

For example, depending on the deep learning-based coding technique used with video encoder (215), the video analytics (102) can include pixel probability model, intra-picture prediction, inter-picture prediction, cross-channel prediction, probability distribution prediction, transform, post-loop filtering, in-loop filtering, down-sampling, up-sampling, encoding optimization, etc.

For example, the video analytics (102) can include identifications, classifications or categories of items, objects, persons, features and/or events shown in images in the input video (104). Further, the video analytics (102) in the output (213) of the artificial neural network (201) can include a location and size of an object, person, or feature recognized from the input video (104). The video encoder (215) can annotate the compressed video (227) using the information/description of the items, objects, persons, features and/or events shown in images in the input video (104).

For example, the video analytics (102) can include representative images/clips of the recognized items, objects, persons, features and/or events shown in images in the input video (104).

In some implementations, the video encoder (215) constructs and generates the compressed video (227) using the representative images/clips and annotate the compressed video (227) with the descriptions of the recognized items, objects, persons, features and/or events shown in images in the input video (104).

For example, the output (213) of the artificial neural network (201) can include an identification of an event associated with the object, person, or feature; and a description coded into the compressed video (227) can include the identification of the event.

Thus, using the video analytics (102) and/or the input video (104), the video encoder (215) generates a compressed video (227). The removable media (191) stores the compressed video (227) as a replacement of the input video (104).

In one embodiment, the input video (104) is a portion of a video stream. After the input video (104) is compressed and stored, another portion of the video stream can be stored into the random access memory (105) in the portion of the random access memory (105) that was previously occupied by the input video (104). Thus, it is not necessary to store the entire uncompressed version of the compressed video (227) in the random access memory (105) at the same time.

In some implementations, the removable media (191) is configured to generate the compressed video (227) on the fly in real time with the streaming of video into the removable media (191). For example, while the input video (104) is being analyzed to generate the video analytics (102), a subsequent portion of the video stream is stored into the random access memory (105) as the next input to the artificial neural network (201). After the subsequent portion of the video stream is received in the removable media (191), the video encoder (215) completes the generation of the compressed video (227) for the input video (104) using the video analytics (102). Thus, the deep learning accelerator (103) can re-execute the instructions to analyze the subsequent portion of the video stream for the video encoder (215) to compress the subsequent portion, while a further portion is being received in the removable media (191) and/or the random access memory (105).

In FIG. 7 an integrated circuit device (101) includes not only a deep learning accelerator (103) and random access memory (105) but also a controller (127), and the logic circuit of a host interface (106) for a wired or wireless connection to the surveillance camera (231) and/or the computer system (223).

In some embodiments, the host interface (106) includes an interface to a memory card reader. The removable media (191) can be configured as a memory card.

In some embodiments, the host interface (106) includes an interface to a plug and play port, such as a universal serial bus (USB) port. The removable media (191) can be configured as a USB drive.

In some embodiments, the host interface (106) includes a transceiver for wired or wireless communications, such as a local area network transceiver, a wireless personal area network transceiver (e.g., a bluetooth transceiver), or a wireless local area network transceiver (e.g., a wi-fi transceiver). The removable media (191) can be configured as a network storage drive.

For example, the controller (127), and the host interface (106) can be formed on an integrated circuit die that is stacked on and connected to the integrated circuit die(s) of the random access memory (105). Thus, the video data received in the host interface (106) can be stored by the controller (127) into the random access memory (105) as the input (211) to the artificial neural network (201) implemented using the deep learning accelerator (103).

The integrated circuit device (101) of FIG. 7 has a controller (127) that is configured to control the operations of the host interface (106), the video encoder (215), and/or the deep learning accelerator (103).

The controller (127) can be implemented, for example, using a microcontroller or a sequencer that controls the timing of the operations of loading the input video (104) into the random access memory (105) and the generation of the compressed video (227) from the input video (104) and the video analytics (102).

Optionally, the controller (127) can be implemented using a microprocessor that runs an application stored in the random access memory (105) as firmware to coordinate the operations among the video encoder (215), the random access memory (105), the deep learning accelerator (103), and/or a host interface (106).

After a set of frames of input video (104) is stored into the random access memory (105) as the input (211) to the artificial neural network (201), the controller (127) can cause the deep learning accelerator (103) to execute the instructions (205) and generate the video analytics (102) as the output (213) of the artificial neural network (201).

For example, the controller (127) can instruct the deep learning accelerator (103) to start the execution of the instructions (205) by writing the address of the input (211) at a predefined location in the random access memory (105). When the deep learning accelerator (103) is in an idle state, the deep learning accelerator (103) can periodically read the address stored at the predefined location in the random access memory (105). When a new and/or valid address is retrieved from the predefined location, the deep learning accelerator (103) starts the execution of the instructions (205). Optionally, after starting the execution of the instructions (205), the deep learning accelerator (103) can optionally clear, erase or invalidate the address previously stored at the predefined location in the random access memory (105).

Alternatively, the controller (127) is configured to send a signal or a message to the deep learning accelerator (103) to instruct the deep learning accelerator (103) to execute the instructions (205). The signal or a message can be transmitted from the controller (127) to the deep learning accelerator (103) using a direct connection that does not go through the memory cells of the random access memory (105).

In some implementations, the controller (127) and the deep learning accelerator (103) have separate connections (109 and 119) to the random access memory (105). When the controller (127) and the deep learning accelerator (103) are not accessing a same block or address of the random access memory (105), the connections (109 and 119) can be used by the controller (127) and the deep learning accelerator (103) in parallel to access different portions of the random access memory (105) simultaneously.

In other implementations, the control unit (113) and the controller (127) can share at least a portion of their circuitry in the deep learning accelerator (103) and use the same memory interface (117) to access the random access memory (105).

A portion of the processing units (111) can be implemented using neuromorphic memory (225). For example, the neuromorphic memory (225) can include a crossbar array of memristors configured to perform multiply-and-accumulate (MAC) operations via analog circuitry. For example, a multiply-accumulate units (e.g., 171 or 173) in a vector-vector unit (e.g., 161) of the deep learning accelerator (103) can be implemented using a crossbar array of memristors. The memristors can be connected in an array with wordlines and bitlines configured to address the memristors as memory cells. A typical memristor is connected to one of the wordlines and one of the bitlines in the array. Electric currents going through the wordlines through a set of memristors in the crossbar array to a bitline are summed in the bitline, which corresponds to the accumulation operation. The electric currents correspond to the multiplication of the voltages applied on the wordlines and parameters associated with the resistances of the memristors, which corresponds to the multiplication operations. The current in the bitline can be compared with a threshold to determine whether a neuron represented by the bitline is activated under the current input. An array of memristors can be connected to the bitlines respectively and programmed to have thresholds corresponding to the activation level thresholds of the neurons. A current detector can be configured for each memristor connected to the output of a bitline to determine whether the level of electric current in the bitline corresponding to a level that exceeds the threshold of the memristor. The neuromorphic memory (225) can perform the multiply-and-accumulate (MAC) operations in a way similar to a memory device reading an array of memory cells and thus with low energy cost and high computation speed.

Through a connection (108) the controller (127) operates the host interface (106) of the integrated circuit device (101) of FIG. 7 to communicate with a surveillance camera (231) and/or a separate computer system (223) through a wired or wireless connection.

For example, the host interface (106) can be configured to communicate according to a communication protocol for a memory card interface, a universal serial bus (USB), a peripheral component interconnect (PCI) bus, a PCI express (PCle) bus, a local area network, a peripheral bus, a mobile industry processor interface (MIPI), a wireless personal area network or a wireless local area network, or a communication protocol of internet of things (IoTs). For example, the host interface (106) can be formed on a radio frequency (RF) complementary metal oxide semiconductor (CMOS) integrated circuit chip.

The host interface (106) can be used by the removable media (191) to receive data and/or instructions from the surveillance camera (231) and/or the computer system (223), such as the configuration parameters (221), the matrices (207) and the instructions (205) of the artificial neural network (201). The host interface (106) can be used by the removable media (191) to provide the compressed video (227) to the computer system (223), or another device.

In some implementations, the host interface (106) includes an interface for receiving a video stream from the surveillance camera (231) for recording, and another interface for direct communication with the computer system (223) without going through the communication interface (237). Thus, the computer system (223) can use the additional interface to access the random access memory (105) in a way that may not be supported by the communication interface (237) of the surveillance camera (231). For example, the computer system (223) can use the additional interface to update the matrices (207), DLA instructions (205), configuration parameters (221), and/or the video encoder (215) in the random access memory (105) without going through the communication interface (237) of the surveillance camera (231). For example, the computer system (223) can use the additional interface to access a portion of the compressed video (227), the input video (104) and/or the video analytics (102).

For example, the computer system (223) can request the removable media (191) and/or the surveillance camera (231) to stream the compressed video (227) to the computer system (223) or another device for playback. Optionally, the controller (127) can decompress the compressed video (227) and stream the video in a resolution and/or format identified in the configuration parameters (221).

In some implementations, the control unit (113) of the deep learning accelerator (103) can include the controller (127); and the logic circuit of the host interface (106) can be implemented on the integrated circuit die of the deep learning accelerator (103), as illustrated in FIG. 8.

In FIG. 8, the deep learning accelerator (103) is configured on an integrated circuit die; and the random access memory (105) is configured on one or more integrated circuit dies. The control unit (113) controls not only the execution of the instructions (205) of the artificial neural network (201), but also the communications of the host interface (106) with the surveillance camera (231) and/or the computer system (223) and the operations of the video encoder (215).

For example, the control unit (113) controls the host interface (106) to receive a video stream from the surveillance camera (231) and stores the input video (104) into the random access memory (105) through the high bandwidth connection (119).

In some implementations, a portion of the video encoder (215) is implemented using logic circuit that is enclosed in an integrated circuit package of an integrated circuit device (101) (e.g., as illustrated in FIG. 7).

Alternatively, the logic circuit of the video encoder (215) can be a separate component (e.g., an integrated circuit chip) that is outside of an integrated circuit package that encloses the deep learning accelerator (103) and the random access memory (105).

For example, an integrated circuit chip of the video encoder (215), and an integrated circuit device (101) having the deep learning accelerator (103) and the random access memory (105) can be mounted on a printed circuit board configured in the removable media (191).

The removable media (191) of FIG. 9 has a substrate (229) that provides connections among its components, such as a deep learning accelerator (103), random access memory (105), a video encoder (215), a controller (127), and a host interface (106).

In some implementations, the substrate (229) includes an integrated circuit die having wires for connecting the components. Some of the components (e.g., the integrated circuit die(s) of the random access memory (105), the deep learning accelerator (103), the controller (127), the video encoder (215), and/or the host interface (106)) can be connected to the integrated circuit die of the substrate (229) via through silicon vias (TSVs). Other components can be connected to the substrate (229) via wire bonding, die attach, or another technique.

In some implementations, the substrate (229) further includes a printed circuit board having wires for connecting the components and other components, such as a power source (e.g., battery), a display, a light-emitting diode (LED) indicator, etc.

In some implementations, the circuits of the host interface (106), the controller (127), the video encoder (215) are integrated in a same integrated circuit chip; and the output of the integrated circuit chip includes a video stream from the surveillance camera (231) to the random access memory (105). In other implementations, the host interface (106) is separate from the integrated circuit chip of the controller (127) and/or the video encoder (215).

In some implementations, the logic circuit of the host interface (106) and/or the controller (127) are configured on the integrated circuit die of the deep learning accelerator (103), or another integrated circuit die.

FIG. 10 shows a method implemented in a surveillance camera according to one embodiment. For example, the method of FIG. 9 can be implemented in a surveillance camera of FIG. 6 with removable media (191) of FIG. 7, FIG. 8, or FIG. 9.

At block 301, a removable data storage device (191) is provided to have random access memory (105) and at least one processing unit (111) configured to perform matrix operations.

For example, the removable data storage device can be a memory card, a universal serial bus (USB) drive, a solid state drive (SSD), a network storage device, etc.

For example, the removable storage media can be a plug and play device that is connectable to a computer system (223) for normal operation and dis-connectable from the computer system (223) without restarting the computer system (223).

For example, the at least one processing unit (111) can be formed on an integrated circuit die of a field-programmable gate array (FPGA) or application specific integrated circuit (ASIC) implementing a deep learning accelerator (103). The deep learning accelerator (103) can include the at least one processing unit (111) for matrix instruction execution, local memory (115) to buffer matrix operands and results, a control unit (113) that can load the instructions (205) from random access memory (105) for execution, and a memory interface (117) to access the random access memory (105).

For example, an integrated circuit package configured to enclose at least the integrated circuit die of FPGA or ASIC and one or more integrated circuit dies of the random access memory. In some implementations, the integrated circuit package further encloses the controller and/or the host interface (106).

For example, the random access memory (105) and the deep learning accelerator (103) are formed on separate integrated circuit dies and connected by through-silicon vias (TSVs).

At block 303, matrices (207) of an artificial neural network (201) and instructions (205) executable to implement computations of the artificial neural network (201) using the matrices (207) are stored into the random access memory (105) of the removable data storage device (191).

For example, the matrices (207) and the instructions (205) can be stored into the removable data storage device (191) before the removable data storage device (191) is installed into a surveillance camera (e.g., 231).

For example, the removable data storage device (191) can be connected to a computer system (223) to store the matrices (207) and the instructions (205) in preparation of the upgrading of the surveillance camera (e.g., 231). To upgrade the surveillance camera (231), an existing removable media (e.g., 192) can be removed from the surveillance camera (231); and then, the removable data storage device (191) having the deep learning accelerator (103) and the random access memory (105) storing the matrices (207) and the instructions (205) can be connected to the surveillance camera (231) as a replacement of the previously installed removable media (192).

At block 305, in response to the removable data storage device (191) being detected in the surveillance camera (231), the surveillance camera (231) configures the removable data storage device (191) as part of the storage capacity of the surveillance camera (231).

For example, the surveillance camera (231) can store a video stream into the removable data storage device (191) in a way same as recording a video stream into the previously installed removable media (192) that does not have a deep learning accelerator (103).

At block 307, a host interface (106) of the removable data storage device (191) received a portion of a video stream (e.g., 104) from the surveillance camera (231). The removable media (191) can store the video stream in its random access memory (105) in a cyclic way where an oldest portion is erased and replaced with a newest portion of the video stream.

For example, the host interface (106) can be configured to communicate with a host (e.g., the surveillance camera (231), the computer system (223)) in accordance with a protocol of a memory card interface, a universal serial bus (USB), a peripheral component interconnect (PCI) bus, a PCI express (PCle) bus, a peripheral bus, a local area network, a mobile industry processor interface (MIPI), a wireless personal area network, a wireless local area network, or internet of things (IoTs), or any combination thereof.

At block 309, at least one processing unit (111) of the removable data storage device (191) executes the instructions (205) to compute output (213) from the artificial neural network (201) that has the portion of the video stream (e.g., 104) as the input (211) to the artificial neural network (201). The output (213) can include video analytics (102) determined by the artificial neural network (201) from the portion of the video stream.

At block 311, the removable data storage device (191) and/or the surveillance camera (231) can provide, based on the video analytics, input to a computer system (223) that is connected to the surveillance camera (231).

For example, the input provided to the computer system (223) can include a compressed video (227) generated based on the video analytics (102) and/or the portion of the video stream (e.g., 104).

For example, the compressed video (227) can be provided to the computer system (223) via the communication interface (237) of the surveillance camera (231) in a way similar to the computer system (223) retrieving a video in the previously installed removable media (192) that does not have a deep learning accelerator (103).

Alternatively, the removable data storage device (191) can include an additional interface for communicating to the computer system (223) directly without going through the existing communication interface (237) of the surveillance camera (231). The additional interface can facilitate a way of accessing the data (e.g., video analytics (102) and/or the input video (104)) in the random access memory (105) that is not supported by the communication interface (237) of the surveillance camera (231).

The content of the compressed video (227) can be substantially the same as the video stream from the image sensor (233) of the surveillance camera (231). For example, a deep learning-based video coding technique implemented based on the video analytics (102) can be used to compress the video stream and generate the compressed video (227).

For example, the removable data storage device (191) can include a video encoder configured to code and generate the compressed video (227) based on the video analytics (102) identifying a pixel probability model, an intra-picture prediction, an inter-picture prediction, a cross-channel prediction, a probability distribution prediction, a transform, a post-loop filtering option, an in-loop filtering option, a down-sampling option, an up-sampling option, or an encoding optimization option, or any combination thereof.

Alternatively, the content of the compressed video (227) can be selectively generated from the video stream captured by the image sensor (233) of the surveillance camera (231), based on what is recognized by the artificial neural network (201) from the video stream.

For example, the video encoder (215) can extract images or clips from the portion of the video stream (e.g., 104) based on the video analytics (102) identifying an object, person, or feature recognized from the portion of the video stream (e.g., 104), and a location and size of the object, person, or feature. The video encoder (215) can construct the compressed video (227) using the images or clips extracted from the portion of the video stream (e.g., 104) and thus discard the remaining video content of the video stream from the image sensor (233).

Optionally, the video encoder (215) can generate a description of content in the portion of the video stream (e.g., 104) based on the video analytics (102) identifying an identification, a classification, or a category of an object, person, or feature recognized by the artificial neural network (201) from the portion of the video stream (e.g., 104), and a location and size of the object, person, or feature. The video encoder (215) can annotate the compressed video (227) according to the description.

In some implementations, the video encoder (215) uses the description of the content of the portion of the video stream (e.g., 104) as the compressed video (227) and as a replacement of the portion of the video stream (e.g., 104). For example, the removable media (191) can provide the description to the computer system (223) without the images or clips extracted from the portion of the video stream (e.g., 104) to show the object, person, or feature recognized by the artificial neural network (201). Optionally, the computer system (223) can optionally request the removable media (191) to provide the images or clips extracted from the portion of the video stream (e.g., 104). In some implementations, the configuration parameters (221) determines whether the removable data storage device (191) provides the compressed video (227) coded using a deep learning-based video coding technique (with or without the description of the content), or the compressed video (227) reconstructed from images/clips of recognized objects, persons, or features that are of interest in a particular surveillance application (with or without the description of the content).

In some implementations, the video encoder (215) is implemented at least in part by a controller (127) executing software instructions.

The video analytics (102) can be generated for the portion of the video stream (e.g., input video (104)) and used to compress the portion (104) during a time period in which a further portion of the video stream is received in the host interface (106). Thus, the compression of the video stream is performed on the fly during the streaming of the video stream from the image sensor (233) of the surveillance camera (231) computer system (223) to the host interface (106).

For example, while a first portion of the video stream is being analyzed using the artificial neural network (201) to generate the video analytics (102) that is then used to compress the first portion, a second portion of the video stream is received in the host interface (106) from the image sensor (233) of the surveillance camera (231) and buffered into the random access memory (105). The compression of the first portion is completed during the streaming of the second portion. After the second portion is buffered in the random access memory (105), the deep learning accelerator (103) executes the instructions (205) again to generate the video analytics (102) of the second portion, while a third portion is received in the host interface (106) from the image sensor (233) of the surveillance camera (231). Since the first portion has been stored as the compressed video, the storage capacity in the random access memory (105) previously used to store/buffer the first portion can be freed to store/buffer the third portion.

The present disclosure includes methods and apparatuses which perform the methods described above, including data processing systems which perform these methods, and computer readable media containing instructions which when executed on data processing systems cause the systems to perform these methods.

A typical data processing system may include an inter-connect (e.g., bus and system core logic), which interconnects a microprocessor(s) and memory. The microprocessor is typically coupled to cache memory.

The inter-connect interconnects the microprocessor(s) and the memory together and also interconnects them to input/output (I/O) device(s) via I/O controller(s). I/O devices may include a display device and/or peripheral devices, such as mice, keyboards, modems, network interfaces, printers, scanners, video cameras and other devices known in the art. In one embodiment, when the data processing system is a server system, some of the I/O devices, such as printers, scanners, mice, and/or keyboards, are optional.

The inter-connect can include one or more buses connected to one another through various bridges, controllers and/or adapters. In one embodiment the I/O controllers include a universal serial bus (USB) adapter for controlling USB peripherals, and/or an IEEE-1394 bus adapter for controlling IEEE-1394 peripherals.

The memory may include one or more of: read only memory (ROM), volatile random access memory (RAM), and non-volatile memory, such as hard drive, flash memory, etc.

Volatile RAM is typically implemented as dynamic RAM (DRAM) which requires power continually in order to refresh or maintain the data in the memory. Non-volatile memory is typically a magnetic hard drive, a magnetic optical drive, an optical drive (e.g., a DVD RAM), or other type of memory system which maintains data even after power is removed from the system. The non-volatile memory may also be a random access memory.

The non-volatile memory can be a local device coupled directly to the rest of the components in the data processing system. A non-volatile memory that is remote from the system, such as a network storage device coupled to the data processing system through a network interface such as a modem or ethernet interface, can also be used.

In the present disclosure, some functions and operations are described as being performed by or caused by software code to simplify description. However, such expressions are also used to specify that the functions result from execution of the code/instructions by a processor, such as a microprocessor.

Alternatively, or in combination, the functions and operations as described here can be implemented using special purpose circuitry, with or without software instructions, such as using application-specific integrated circuit (ASIC) or field-programmable gate array (FPGA). Embodiments can be implemented using hardwired circuitry without software instructions, or in combination with software instructions. Thus, the techniques are limited neither to any specific combination of hardware circuitry and software, nor to any particular source for the instructions executed by the data processing system.

While one embodiment can be implemented in fully functioning computers and computer systems, various embodiments are capable of being distributed as a computing product in a variety of forms and are capable of being applied regardless of the particular type of machine or computer-readable media used to actually effect the distribution.

At least some aspects disclosed can be embodied, at least in part, in software. That is, the techniques may be carried out in a computer system or other data processing system in response to its processor, such as a microprocessor, executing sequences of instructions contained in a memory, such as ROM, volatile RAM, non-volatile memory, cache or a remote storage device.

Routines executed to implement the embodiments may be implemented as part of an operating system or a specific application, component, program, object, module or sequence of instructions referred to as “computer programs.” The computer programs typically include one or more instructions set at various times in various memory and storage devices in a computer, and that, when read and executed by one or more processors in a computer, cause the computer to perform operations necessary to execute elements involving the various aspects.

A machine readable medium can be used to store software and data which when executed by a data processing system causes the system to perform various methods. The executable software and data may be stored in various places including for example ROM, volatile RAM, non-volatile memory and/or cache. Portions of this software and/or data may be stored in any one of these storage devices. Further, the data and instructions can be obtained from centralized servers or peer to peer networks. Different portions of the data and instructions can be obtained from different centralized servers and/or peer to peer networks at different times and in different communication sessions or in a same communication session. The data and instructions can be obtained in entirety prior to the execution of the applications. Alternatively, portions of the data and instructions can be obtained dynamically, just in time, when needed for execution. Thus, it is not required that the data and instructions be on a machine readable medium in entirety at a particular instance of time.

Examples of computer-readable media include but are not limited to non-transitory, recordable and non-recordable type media such as volatile and non-volatile memory devices, read only memory (ROM), random access memory (RAM), flash memory devices, floppy and other removable disks, magnetic disk storage media, optical storage media (e.g., compact disk read-only memory (CD ROM), digital versatile disks (DVDs), etc.), among others. The computer-readable media may store the instructions.

The instructions may also be embodied in digital and analog communication links for electrical, optical, acoustical or other forms of propagated signals, such as carrier waves, infrared signals, digital signals, etc. However, propagated signals, such as carrier waves, infrared signals, digital signals, etc. are not tangible machine readable medium and are not configured to store instructions.

In general, a machine readable medium includes any mechanism that provides (i.e., stores and/or transmits) information in a form accessible by a machine (e.g., a computer, network device, personal digital assistant, manufacturing tool, any device with a set of one or more processors, etc.).

In various embodiments, hardwired circuitry may be used in combination with software instructions to implement the techniques. Thus, the techniques are neither limited to any specific combination of hardware circuitry and software nor to any particular source for the instructions executed by the data processing system.

The above description and drawings are illustrative and are not to be construed as limiting. Numerous specific details are described to provide a thorough understanding. However, in certain instances, well known or conventional details are not described in order to avoid obscuring the description. References to one or an embodiment in the present disclosure are not necessarily references to the same embodiment; and, such references mean at least one.

In the foregoing specification, the disclosure has been described with reference to specific exemplary embodiments thereof. It will be evident that various modifications may be made thereto without departing from the broader spirit and scope as set forth in the following claims. The specification and drawings are, accordingly, to be regarded in an illustrative sense rather than a restrictive sense.

Claims

1. A device, comprising: a controller; anda slot coupled to the controller and configured to receive a removable media;wherein the removable media comprises: a memory configured to store data representative of an artificial neural network; andat least one processing unit configured to perform computations of the artificial neural network based on the data stored in the memory; andwherein the removable media is configured to process data written by the controller into the removable media using the artificial neural network.

2. The device of claim 1, further comprising: a camera configure to generate video data to be written by the controller into the removable media.

3. The device of claim 2, wherein the removable media further includes a host interface operable to receive write commands from the controller when the removable media is inserted into the slot.

4. The device of claim 3, wherein the removable media is further configured to store an output of the artificial neural network responsive to an input corresponding to the video data written by the controller into the removable media.

5. The device of claim 4, wherein the output includes a description of content in the video data.

6. The device of claim 4, wherein the output includes analytics of the video data written by the controller into the removable media.

7. The device of claim 6, wherein the removable media is further configured to generate a compressed video based on the video data and the analytics.

8. The device of claim 7, wherein the removable media is further configured to store the compressed video as a replacement of the video data written by the controller into the removable media.

9. The device of claim 8, wherein the removable media is configured in a form of a solid state drive, a memory card, a network storage device, or a universal serial bus (USB) drive.

10. The device of claim 9, wherein the removable media further comprises: an integrated circuit package configured to enclose at least the memory and the at least one processing unit.

11. A method, comprising: storing, in a memory of a removable media, first data representative of an artificial neural network;receiving, in a slot of a device having controller, the removable media;writing, by the controller, second data into the removable media;performing, by at least one processing unit configured in the removable media, computations of the artificial neural network based on the first data stored in the memory; andprocessing, by the removable media, the second data written by the controller into the removable media using the artificial neural network.

12. The method of claim 11, further comprising: generating, by a camera configured in the device, the second data to be written by the controller into the removable media, the second data including video data;wherein the removable media further includes a host interface operable to receive write commands from the controller when the removable media is inserted into the slot.

13. The method of claim 12, further comprising: storing, by the removable media, an output of the artificial neural network responsive to an input corresponding to the video data written by the controller into the removable media.

14. The method of claim 13, wherein the output includes a description of content in the video data, or analytics of the video data written by the controller into the removable media, or any combination thereof.

15. The method of claim 14, further comprising: generating, by the removable media, a compressed video based on the video data and the analytics.

16. The method of claim 15, further comprising: storing, by the removable media, the compressed video as a replacement of the video data written by the controller into the removable media.

17. The method of claim 16, wherein the removable media is configured in a form of a solid state drive, a memory card, a network storage device, or a universal serial bus (USB) drive; and wherein the removable media further comprises an integrated circuit package configured to enclose at least the memory and the at least one processing unit.

18. A non-transitory computer storage medium storing instructions which, when executed in a device, cause the device to perform a method, the method comprising: recognizing, in a slot of the device having controller, a removable media storing first data representative of an artificial neural network;writing, by the controller, second data into the removable media;performing, by at least one processing unit configured in the removable media, computations of the artificial neural network based on the first data stored in the removable media; andprocessing, by the removable media, the second data written by the controller into the removable media using the artificial neural network.

19. The non-transitory computer storage medium of claim 18, wherein the method further comprises: generating, by a camera configured in the device, the second data to be written by the controller into the removable media, the second data including video data; andstoring, by the removable media, an output of the artificial neural network responsive to an input corresponding to the video data written by the controller into the removable media;wherein the output includes a description of content in the video data, or analytics of the video data written by the controller into the removable media, or any combination thereof.

20. The non-transitory computer storage medium of claim 19, wherein the method further comprises: generating, by the removable media, a compressed video based on the video data and the analytics; andstoring, by the removable media, the compressed video as a replacement of the video data written by the controller into the removable media.