EFFICIENT OBJECT SEGMENTATION

In implementations of systems for efficient object segmentation, a computing device implements a segment system to receive a user input specifying coordinates of a digital image. The segment system computes receptive fields of a machine learning model based on the coordinates of the digital image. The machine learning model is trained on training data to generate segment masks for objects depicted in digital images. The segment system processes a portion of a feature map of the digital image using the machine learning model based on the receptive fields. A segment mask is generated for an object depicted in the digital image based on processing the portion of the feature map of the digital image using the machine learning model.

BACKGROUND

Object segmentation refers to a machine learning task in which objects depicted in a digital image are separated or segmented by generating pixel-level masks for the objects. The pixel-level masks are generated using a machine learning model such as a convolutional neural network trained on training data to generate pixel-level masks for objects depicted in digital images. Once generated, the pixel-level masks are usable to support a variety of functionality such as removing an object from the digital image, applying edits that change a visual appearance of the object without changing a visual appearance of other objects depicted in the digital image, etc.

SUMMARY

Techniques and systems for efficient object segmentation are described. In an example, a computing device implements a segment system to receive a user input specifying coordinates of a digital image. For example, the coordinates of the digital image are coordinates of a pixel that is included in an object depicted in the digital image. The segment system computes receptive fields for nodes (e.g., artificial neurons) of layers of a machine learning model based on the coordinates of the digital image.

For instance, the machine learning model is trained on training data to generate segment masks for objects depicted in digital images. In an example, the segment system processes a portion of a feature map of the digital image using the machine learning model based on the receptive fields (e.g., a union of the receptive fields). In this example, the segment system generates a segment mask for the object depicted in the digital image based on processing the portion of the feature map of the digital image using the machine learning model.

DETAILED DESCRIPTION

Overview

Single-instance segmentation is a type of object segmentation in which a segment mask is generated for a single object (e.g., of multiple objects) depicted in a digital image using a machine learning model trained on training data to generate segment masks for objects depicted in digital images. Conventional systems for single-instance segmentation process an entire digital image (and corresponding feature map of the digital image) to attend to all objects depicted in the digital image and then generate a segment mask for a particular one of the objects depicted in the digital image. This involves performing computations (e.g., convolutions) for portions of the digital image which are not useful for generating the segment mask for the particular one of the objects which is inefficient. In order to overcome the limitations of conventional systems, techniques and systems for efficient object segmentation are described.

In an example, a computing device implements a segment system to receive a user input specifying coordinates of a digital image. For example, a user interacts with an input device (e.g., a touchscreen, a stylus, a mouse, a keyboard, etc.) relative to the digital image to specify the coordinates as being included in an object depicted in the digital image. In this example, the digital image is displayed in a user interface, and the user manipulates the input device to specify the coordinates in order to segment the object from other portions of the digital image (e.g., other objects depicted in the digital image).

In one example, the segment system generates a feature map of the digital image using a backbone network included in a machine learning model. For instance, the backbone network includes a feature pyramid network and the feature map for the digital image is a multi-level feature pyramid. In order to generate a segment mask for the object depicted in the digital image without processing portions of the digital image and portions of the feature map of the digital image that are not useful for segmenting the object, the segment system uses the coordinates to compute receptive fields for nodes (e.g., artificial neurons) of layers of a convolutional neural network included in the machine learning model.

For example, the convolutional neural network is trained on training data to generate segment masks for objects depicted in digital images. In an example, the segment system performs receptive field tracing to compute the receptive fields by starting at a lowest layer of the convolutional neural network and identifying a first node (or nodes) included in the lowest layer that is activated by (e.g., responds to) a region of the feature map of the digital image which corresponds to the coordinates specified by the user. The segment system uses the first node (or nodes) to trace dependencies of nodes between layers of the network from the lowest layer to a highest layer of the convolutional neural network in order to identify all nodes of the network capable of contributing to an output at the coordinates.

To do so in one example, the segment system computes a first receptive field for the first node (or nodes) of the lowest layer, and then identifies a second node (or nodes) of a second lowest layer of the convolutional neural network that is capable of contributing to an output of the first node (or nodes) of the lowest layer. For example, the segment system identifies the second node (or nodes) by performing receptive field tracing, and then computes a second receptive field for the second node (or nodes). In this example, the segment system continues to perform receptive field tracing to identify nodes of higher layers of the convolutional neural network that are capable of contributing to outputs of nodes of lower layers of the convolutional neural network until a node (or nodes) of the highest layer of the convolutional neural network is identified and a receptive field for the node (or nodes) of the highest layer is computed. It is to be appreciated that the receptive field tracing is more complex for different architectures of the convolutional neural network such as architectures including skip connections between nodes.

After performing receptive field tracing from the lowest layer of the convolutional neural network to the highest layer of the convolutional neural network, the segment system identifies any dependencies between nodes of the higher layers and nodes of the lower layers of the network from the highest layer of the convolutional neural network to the lowest layer of the convolutional neural network. For example, the segment system increases sizes of the receptive fields based on any identified dependencies. The segment system then determines an approximate layer receptive field by computing a union of the receptive fields. In an example, the segment system utilizes the approximate layer receptive field to “crop” out features which are not capable of contributing to an output at the coordinates during an inference performed by the convolutional neural network.

In one example, the segment system generates a segment mask for the object depicted in the digital image by implementing the convolutional neural network using the approximate layer receptive field to avoid processing portions of the digital image or portions of the feature map of the digital image that are not useful for segmenting the object. Because the described systems for efficient object segmentation are capable of avoiding processing portions of digital images and corresponding feature maps which are not useful for segmenting objects depicted in the digital images, segment masks generated by the described systems utilize less processing/memory resources than segment masks generated by conventional systems which are not capable of avoiding processing of entire digital images and corresponding feature maps. For instance, in an evaluation of floating point operations per second at inference, the described systems for efficient object segmentation demonstrated computation reductions of between 43 and 60 percent for instance segmentation tasks relative to the conventional systems for the instance segmentation tasks.

In the following discussion, an example environment is first described that employs examples of techniques described herein. Example procedures are also described which are performable in the example environment and other environments. Consequently, performance of the example procedures is not limited to the example environment and the example environment is not limited to performance of the example procedures.

Example Environment

FIG.1is an illustration of an environment100in an example implementation that is operable to employ digital systems and techniques as described herein. The illustrated environment100includes a computing device102connected to a network104. The computing device102is configurable as a desktop computer, a laptop computer, a mobile device (e.g., assuming a handheld configuration such as a tablet or mobile phone), and so forth. Thus, the computing device102is capable of ranging from a full resource device with substantial memory and processor resources (e.g., personal computers, game consoles) to a low-resource device with limited memory and/or processing resources (e.g., mobile devices). In some examples, the computing device102is representative of a plurality of different devices such as multiple servers utilized to perform operations “over the cloud.”

The illustrated environment100also includes a display device106that is communicatively coupled to the computing device102via a wired or a wireless connection. A variety of device configurations are usable to implement the computing device102and/or the display device106. For example, the display device106and the computing device102are illustrated to be integrated as part of a mobile device such as a smartphone. The computing device102includes a storage device108and a segment module110. For instance, the storage device108is illustrated to include digital content112such as digital images, digital artwork, digital videos, etc.

The segment module110is illustrated as having, receiving, and/or transmitting input data114. As shown, the input data114describes a user input specifying coordinates116of a digital image118that depicts an object120which is a teddy bear. For example, a user interacts with an input device (e.g., a mouse, a stylus, a keyboard, a touchscreen, a microphone, etc.) relative to the digital image118in order to specify the coordinates116.

In one example, the user generates the input data114by performing a single interaction relative to a user interface122of the display device106(e.g., by contacting the user interface122with a finger or a stylus to specify the coordinates116). In some examples, the user specifies the coordinates116relative to the object120in order to segment the object120. In these examples, by segmenting the object120it is possible to remove the object120from the digital image118, to apply editing operations that change visual features of the object120without changing visual features of other portions of the digital image118, and so forth.

In an example, the segment module110receives and processes the input data114in order to segment the object120using a machine learning model that is included in or accessible to the segment module110. In this example, the machine learning model is trained on training data to segment objects depicted in digital images. As used herein, the term “machine learning model” refers to a computer representation that is tunable (e.g., trainable) based on inputs to approximate unknown functions. By way of example, the term “machine learning model” includes a model that utilizes algorithms to learn from, and make predictions on, known data by analyzing the known data to learn to generate outputs that reflect patterns and attributes of the known data. According to various implementations, such a machine learning model uses supervised learning, semi-supervised learning, unsupervised learning, reinforcement learning, and/or transfer learning. For example, the machine learning model is capable of including, but is not limited to, clustering, decision trees, support vector machines, linear regression, logistic regression, Bayesian networks, random forest learning, dimensionality reduction algorithms, boosting algorithms, transformers, artificial neural networks (e.g., fully-connected neural networks, deep convolutional neural networks, or recurrent neural networks), deep learning, autoregressive models, etc. By way of example, a machine learning model makes high-level abstractions in data by generating data-driven predictions or decisions from the known input data.

It is possible for the segment module110to segment the object120by processing the digital image118in its entirety using the machine learning model; however, processing of the digital image118in its entirety is not an efficient technique for segmenting the object120because it causes the machine learning model to perform more computations (e.g., convolutions) than necessary to segment the object120. In an example, the machine learning model includes a convolutional neural network trained on training data to identify instances of objects depicted in digital images by attending to all portions of the digital images. In this example, the machine learning model is also trained on the training data to predict pixel-level masks of identified instances of the objects depicted in the digital images.

Consider another example in which the machine learning model is trained on training data to perform instance segmentation of objects depicted in digital images. For example, the machine learning model processes portions of the digital image118other than the object120as part of identifying all instances of objects depicted in the digital image118. Since the coordinates116are specified relative to the object120in order to segment the object120, it is not necessary for the machine learning model to process the portions of the digital image118that do not depict the object120.

In order to avoid processing the portions of the digital image118which are not useful for segmenting the object120, the segment module110computes receptive fields of nodes (e.g., artificial neurons) of layers of the machine learning model based on the coordinates116of the digital image118. In an example, the segment module110generates a feature map (e.g., an output feature map) of the digital image118by processing the digital image118using a backbone network such as a feature pyramid network. For example, using the coordinates116and the feature map of the digital image118, the segment module110identifies a node (or nodes) of a lowest layer of the machine learning model that is activated by (e.g., responds to) a region of the feature map which corresponds to the coordinates116.

The segment module110computes a first receptive field (e.g., a size of the first receptive field based on a size of a filter and a stride) for the node (or nodes) of the lowest layer of the machine learning model, and the segment module110performs receptive field tracing to identify a node (or nodes) of a second lowest layer of the machine learning model that is capable of contributing to an output of the node (or nodes) of the lowest layer of the machine learning model. For instance, the segment module110computes a second receptive field (e.g., a size of the second receptive field based on the filter and the stride) for the node (or nodes) of the second lowest layer of the machine learning model. In an example, the segment module110adds the second receptive field to the first receptive field, and then the segment module110performs receptive field tracing to identify a node (or nodes) of a third lowest layer of the machine learning model that is capable of contributing to an output of the node (or nodes) of the second lowest layer of the machine learning model. The segment module110repeats this process for each layer of the machine learning model.

For example, after performing receptive field tracing and computing receptive field sizes for nodes from the lowest layer of the machine learning model to a highest layer of the machine learning model (e.g., tracing from the feature map of the digital image118to the digital image118as an input to the machine learning model), the segment module110uses the computed receptive field sizes to avoid performing computations for features which are not capable of contributing to an output at the coordinates116. In this example, the segment module110computes a union of the receptive field sizes and uses the computed union to “crop” out the features which are not capable of contributing to the output at the coordinates116during an inference performed by the machine learning model. To do so in one example, the segment module110determines whether any dependencies (e.g., between nodes of layers of the machine learning model from the highest layer to the lowest layer) necessitate a larger field than the union and the segment module110computes an approximate layer receptive field for use during the inference performed by the model. The segment module110does not process feature values that are outside of the approximate layer receptive field during the inference performed by the machine learning model in order to segment the object120.

In this manner, the segment module110processes a portion of the feature map of the digital image118instead of an entirety of the feature map of the digital image118in order to generate a segment mask124for the object120depicted in the digital image118. By not processing the portions of the digital image118which are not useful for segmenting the object120, the segment module110is capable of generating the segment mask124in less time and using less computational/memory resources than conventional systems which process an entirety of the digital image118in order to generate the segment mask124. This improvement facilitates performance of instance segmentation tasks in examples in which the computing device102is a low-resource device with limited memory and/or processing resources such as a mobile device.

FIG.2depicts a system200in an example implementation showing operation of segment module110. The segment module110is illustrated to include a tracing module202, an inference module204, and a display module206. In one example, the tracing module202receives and processes the input data114in order to generate receptive field data208.

FIG.3illustrates a representation300of examples of input data114. As shown in the representation300, the input data114describes a digital image302which depicts multiple different objects in three examples304-308. In a first example304, a user manipulates an input device (e.g., a mouse, a touchscreen, a stylus, a keyboard, a microphone, etc.) relative to the digital image302to specify coordinates310of a first object depicted in the digital image302. For example, the first object is a stuffed animal.

FIG.4illustrates a representation400of a machine learning model402. In an example, the machine learning model402is included in the segment module110. In another example, the machine learning model402is accessible to the segment module110such as via the network104. The machine learning model402includes a convolutional neural network in some examples such as ResNet-101, ResNet-50, etc. In other examples, the machine learning model402includes a machine learning model trained on training data to segment instances of objects depicted in digital images.

For example, the machine learning model402includes a backbone network404which is capable of generating feature maps of digital images. In one example, the backbone network404includes a feature pyramid network which processes the digital image302and generates a feature map of the digital image302by extracting a multi-level feature pyramid over the convolutional neural network (e.g., ResNet-101, ResNet-50, etc.) included in the machine learning model402. In this example, each level of the feature pyramid is used to extract local features around the coordinates310at different scales.

The tracing module202receives the input data114as describing the digital image302and the coordinates310, and the tracing module202processes the input data114using a receptive field tracer406. For instance, the receptive field tracer406is included in or available to the tracing module202. In an example, the tracing module202utilizes the receptive field tracer406to perform receptive field tracing for nodes (e.g., artificial neurons) of layers of the convolutional neural network included in the machine learning model402based on the digital image302and the coordinates310described by the input data114. For example, the tracing module202computes a feature map of the digital image302using the backbone network404as part of performing the receptive field tracing.

In one example, the tracing module202defines a receptive field region for an n-layer convolutional neural network by assuming pixels on each layer are indexed by (i,j), with an upper-left most pixel at (0,0). In this example, the tracing module202denotes an (i,j)th pixel on a pth layer as xi,jpwhere p ∈ [n] and xi,j0denotes a pixel value of the digital image302and xi,jndenotes an output from the n-layer convolutional neural network. The tracing module202defines a p-layer receptive field region rpof xi,jnas including a set of all units in an output feature map of a pth layer xpthat contribute to xi,jnfor any p ∈ [n].

For example, the tracing module202defines a feature map fpas an output feature map of a pth layer for a convolutional neural network having P layer operations. For any p ∈ [P−1], the tracing module202determines a recursive and invertible mapping function that maps rp+1with respect to fp+1to rpwith respect to fpbased on a type of layer (p+1) and a list of parameters Ap+1that characterize the layer (p+1). In an example, this is representable as:

where: F represents the mapping function.

In some examples, the tracing module202defines additional parameters as:

The tracing module202denotes upand vpas left-most and right-most zero-indexed coordinates of rpwith respect to fpin order to represent:

FIG.5illustrates a representation500of computing receptive fields for nodes of layers of a machine learning model. For instance, the representation500includes a lowest layer502, an intermediate layer504, and a highest layer506of the convolutional neural network that is included in the machine learning model402. As shown, the lowest layer502includes nodes508-522(e.g., artificial neurons); the intermediate layer504includes nodes524-538; and the highest layer506includes nodes540-554.

For example, the tracing module202utilizes the digital image302the feature map of the digital image302(e.g., generated using the backbone network404), and the coordinates310to identify a node514of the lowest layer502as being activated by (e.g., responding to) a region of the feature map of the digital image302that corresponds to the coordinates310. The tracing module202computes a receptive field for the node514and performs receptive field tracing using the receptive field tracer406to identify nodes528,532of the intermediate layer504as being capable of contributing to an output of the node514. In an example, the tracing module202determines a dependency556between the node514and the node528and also a dependency558between the node514and the node532.

In an example, the tracing module202performs receptive field tracing using the receptive field tracer406to identify nodes542,544of the highest layer506as being capable of contributing to an output of the node528. In this example, the tracing module determines a dependency560between the node528and the node542and a dependency562between the node528and the node544. In an example, the tracing module202uses the receptive field tracer406to identify nodes546,550of the highest layer506as being capable of contributing to an output of the node532. The tracing module202determines a dependency564between the node532and the node546and also determines a dependency566between the node532and the node550.

FIG.6illustrates a representation600of a computational graph for efficient object segmentation. As shown in the representation600, the computational graph visually illustrates dependencies between nodes of layers of the convolutional neural network from an origin602. Although the dependencies556-566illustrate liner dependencies in one example, it is to be appreciated that in other examples, the dependencies556-566are non-linear and include skip connections which bypass, e.g., the intermediate layer504. The computational graph included in the representation600illustrates dependencies between nodes of layers of an example ResNet-50 architecture.

FIG.7illustrates a representation700of processing a portion of a feature map of a digital image using a machine learning model. The representation700includes the lowest layer502, the intermediate layer504, and the highest layer506of the convolutional neural network that is included in the machine learning model402. The tracing module202uses the receptive field tracer406to identify a dependency702between the node542of the highest layer506and node524of the intermediate layer504and also to identify a dependency704between the node542and node530of the intermediate layer504.

For example, the tracing module202identifies a dependency706between the node550of the highest layer506and node534of the intermediate layer504. In this example, the tracing module202also identifies a dependency708between the node550and node536of the intermediate layer504. For instance, the tracing module202identifies a dependency710between the node524and node508of the lowest layer502and also a dependency712between the node524and node510of the lowest layer502. Similarly, the tracing module202identifies a dependency714between the node536and node518of the lowest layer502, and the tracing module202also identifies a dependency716between the node536and node520of the lowest layer502.

As shown in the representation700, the tracing module202determines an approximate layer receptive field718by computing unions of receptive fields computed for the nodes508-554. In one example, this is representable as:

where: F represents the recursive and invertible mapping function that maps receptive regions of child nodes to receptive field regions with respect to a current feature map based on a type of child layer operation such as Convolution, Activation, Pooling, Normalization, Interpolation, etc.

For example, the tracing module202generates the receptive field data208as describing the approximate layer receptive field718. In an example, the inference module204receives and processes the receptive field data208in order to perform efficient object segmentation with respect to the digital image302.FIG.8illustrates a representation800of segment masks generated for objects depicted in a digital image.

As shown, the representation800includes the first example304, the second example306, and the third example308. In the first example304in which the user specified the coordinates310relative to the first object depicted in the digital image302, the inference module204utilizes the approximate layer receptive field718to generate a first segment mask802for the first object without processing portions of the digital image302or portions of the feature map of the digital image302that are not useful for segmenting the first object using the convolutional neural network included in the machine learning model402. To do so in one example, the inference module204utilizes the approximate layer receptive field718such that for any p-layer and any child node plof the p-layer, a receptive field region controller “crops” the feature map with a memorized output from F and pads a memorized padding value at four borders for next-layer feature computation in pl.

In the second example306in which the user specified the coordinates310relative to the second object depicted in the digital image302, the inference module204generates a second segment mask804for the second object and uses the approximate layer receptive field718to generate the second segment mask804without processing portions of the digital image302or portion of the feature map of the digital image302that are not useful for segmenting the second object. In an example, the inference module204generates the second segment mask804using the convolutional neural network that is included in the machine learning model402. In the third example308in which the user specified the coordinates310relative to the third object depicted in the digital image302, the inference module204implements the convolutional neural network included in the machine learning model402to generate a third segment mask806for the third object. For instance, the inference module204generates the third segment mask806by using the approximate layer receptive field718to avoid processing portions of the digital image302or portions of the feature map of the digital image302which are not useful for segmenting the third object.

The inference module204generates mask data210describing the first segment mask802, the second segment mask804, and the third segment mask806. For example, the display module206receives and processes the mask data210to generate an indication of the first segment mask802, an indication of the second segment mask804, and an indication of the third segment mask806for display in the user interface122of the display device106. By performing receptive field tracing to compute receptive fields for nodes of layers of the convolutional neural network and using the computed receptive fields to avoid causing the convolutional neural network to perform unnecessary computations (e.g., convolutions), the described systems for efficient object segmentation are capable of generating segment masks for objects depicted in digital images in less time and using less computational and memory resources than conventional systems that process a digital image in its entirety in order to identify and segment objects depicted in the digital image.

In an example evaluation of floating point operations per second at inference of the described systems for efficient object segmentation relative to conventional systems utilizing a feature pyramid network as the backbone network404and ResNet-50 as the convolutional neural network, the described systems reduced computations by about 60.2 percent compared to the conventional systems. In a similar evaluation between the described systems for efficient object segmentation and the conventional systems using ResNet-101 as the convolutional neural network, the described systems reduced floating point operations per second at inference by about 43.6 percent compared to the conventional systems.

In general, functionality, features, and concepts described in relation to the examples above and below are employed in the context of the example procedures described in this section. Further, functionality, features, and concepts described in relation to different figures and examples in this document are interchangeable among one another and are not limited to implementation in the context of a particular figure or procedure. Moreover, blocks associated with different representative procedures and corresponding figures herein are applicable individually, together, and/or combined in different ways. Thus, individual functionality, features, and concepts described in relation to different example environments, devices, components, figures, and procedures herein are usable in any suitable combinations and are not limited to the particular combinations represented by the enumerated examples in this description.

Example Procedures

The following discussion describes techniques which are implementable utilizing the previously described systems and devices. Aspects of each of the procedures are implementable in hardware, firmware, software, or a combination thereof. The procedures are shown as a set of blocks that specify operations performed by one or more devices and are not necessarily limited to the orders shown for performing the operations by the respective blocks. In portions of the following discussion, reference is made toFIGS.1-8.FIG.9is a flow diagram depicting a procedure900in an example implementation in which receptive fields of a machine learning model are computed based on coordinates of a digital image.

A user input is received specifying coordinates of a digital image (block902). For example, the computing device102implements the segment module110to receive the user input. Receptive fields of a machine learning model are computed based on the coordinates of the digital image, and the machine learning model is trained on training data to generate segment masks for objects depicted in digital images (block904). In one example, the segment module110computes the receptive fields of the machine learning model.

A portion of a feature map of the digital image is processed using the machine learning model based on the receptive fields (block906). In some examples, the computing device102implements the segment module110to process the portion of the feature map of the digital image using the machine learning model. A segment mask is generated for an object depicted in the digital image based on processing the portion of the feature map of the digital image using the machine learning model (block908). In an example, the segment module110generates the segment mask for the object depicted in the digital image.

FIG.10is a flow diagram depicting a procedure1000in an example implementation in which a segment mask is generated for an object depicted in a digital image based on processing a portion of a feature map of the digital image using a machine learning model. A user input defining input coordinates of a pixel of a digital image is received, and the pixel is included in an object depicted in the digital image (block1002). For example, the computing device102implements the segment module110to receive the user input defining the input coordinates of the pixel of the digital image.

Receptive fields for nodes of layers of a machine learning model are computed based on the input coordinates of the pixel (block1004). In some examples, the segment module110computes the receptive fields for the nodes of the layers of the machine learning model. A portion of a feature map of the digital image is processed using the machine learning model based on the receptive fields for the nodes of the layers (block1006). In one example, the segment module110processes the portion of the feature map of the digital image using the machine learning model. A segment mask is generated for the object based on processing the portion of the feature map of the digital image using the machine learning model (block1008). The segment module110generates the segment mask for the object in an example.

Example System and Device

FIG.11illustrates an example system1100that includes an example computing device that is representative of one or more computing systems and/or devices that are usable to implement the various techniques described herein. This is illustrated through inclusion of the segment module110. The computing device1102includes, for example, a server of a service provider, a device associated with a client (e.g., a client device), an on-chip system, and/or any other suitable computing device or computing system.

The processing system1104is representative of functionality to perform one or more operations using hardware. Accordingly, the processing system1104is illustrated as including hardware elements1110that are configured as processors, functional blocks, and so forth. This includes example implementations in hardware as an application specific integrated circuit or other logic device formed using one or more semiconductors. The hardware elements1110are not limited by the materials from which they are formed or the processing mechanisms employed therein. For example, processors are comprised of semiconductor(s) and/or transistors (e.g., electronic integrated circuits (ICs)). In such a context, processor-executable instructions are, for example, electronically-executable instructions.

The computer-readable media1106is illustrated as including memory/storage1112. The memory/storage1112represents memory/storage capacity associated with one or more computer-readable media. In one example, the memory/storage1112includes volatile media (such as random access memory (RAM)) and/or nonvolatile media (such as read only memory (ROM), Flash memory, optical disks, magnetic disks, and so forth). In another example, the memory/storage1112includes fixed media (e.g., RAM, ROM, a fixed hard drive, and so on) as well as removable media (e.g., Flash memory, a removable hard drive, an optical disc, and so forth). The computer-readable media1106is configurable in a variety of other ways as further described below.

Implementations of the described modules and techniques are storable on or transmitted across some form of computer-readable media. For example, the computer-readable media includes a variety of media that is accessible to the computing device1102. By way of example, and not limitation, computer-readable media includes “computer-readable storage media” and “computer-readable signal media.”

Combinations of the foregoing are also employable to implement various techniques described herein. Accordingly, software, hardware, or executable modules are implementable as one or more instructions and/or logic embodied on some form of computer-readable storage media and/or by one or more hardware elements1110. For example, the computing device1102is configured to implement particular instructions and/or functions corresponding to the software and/or hardware modules. Accordingly, implementation of a module that is executable by the computing device1102as software is achieved at least partially in hardware, e.g., through use of computer-readable storage media and/or hardware elements1110of the processing system1104. The instructions and/or functions are executable/operable by one or more articles of manufacture (for example, one or more computing devices1102and/or processing systems1104) to implement techniques, modules, and examples described herein.

The techniques described herein are supportable by various configurations of the computing device1102and are not limited to the specific examples of the techniques described herein. This functionality is also implementable entirely or partially through use of a distributed system, such as over a “cloud”1114as described below.

The cloud1114includes and/or is representative of a platform1116for resources1118. The platform1116abstracts underlying functionality of hardware (e.g., servers) and software resources of the cloud1114. For example, the resources1118include applications and/or data that are utilized while computer processing is executed on servers that are remote from the computing device1102. In some examples, the resources1118also include services provided over the Internet and/or through a subscriber network, such as a cellular or Wi-Fi network.

The platform1116abstracts the resources1118and functions to connect the computing device1102with other computing devices. In some examples, the platform1116also serves to abstract scaling of resources to provide a corresponding level of scale to encountered demand for the resources that are implemented via the platform. Accordingly, in an interconnected device embodiment, implementation of functionality described herein is distributable throughout the system1100. For example, the functionality is implementable in part on the computing device1102as well as via the platform1116that abstracts the functionality of the cloud1114.

CONCLUSION

Although implementations of systems for efficient object segmentation have been described in language specific to structural features and/or methods, it is to be understood that the appended claims are not necessarily limited to the specific features or methods described. Rather, the specific features and methods are disclosed as example implementations of systems for efficient object segmentation, and other equivalent features and methods are intended to be within the scope of the appended claims. Further, various different examples are described and it is to be appreciated that each described example is implementable independently or in connection with one or more other described examples.