We believe artificial intelligence is here to empower us, not replace us. Our innovative development products will help you better understand, design, and develop AI solutions that empower others.
In our latest release, version 0.11.6.86, we have made a lot of upgrades including now supporting both Windows 10 and Windows 11 with Visual Studio 2022 and the latest CUDA 11.6 and cuDNN 8.3.2 from NVIDIA.
New Features
The following new features have been added to this release.
CUDA 11.6.0.511/cuDNN 8.3.2.44/nvapi 510/driver 511.65
Windows 11 21H1, OS Build 22000.493
Windows 10 21H1, OS Build 19043.1320, SDK 10.0.19041.0
Upgraded to Visual Studio 2022 Builds
Upgraded to .NET 4.8
Improved error messages when clicking on error in output window.
Added Label Image comparison.
Added save image-to-image viewers.
Improved global error handling.
Added SERF activation layer.
Training dataset used for testing, when no testing images exist.
Bug Fixes
Fixed bug when canceling from Create Test Results not enabling controls.
Fixed radio button bug on LabelBoost dialog.
Fixed bug where use_mean_image was not exported.
Fixed bugs related to NVAPI use for temperature and utilization when in TCC mode.
Fixed lockup caused at times when clearing status.
Fixed bug RESIZE doesn’t restart after being cancelled.
Fixed bug where RESIZE allows creating duplicate data sources.
Fixed bugs related to GPU resource status.
Fixed crash caused when running Extension functions.
Fixed bugs in low level memory freeing, added synchronization.
The US Securities and Exchange Commission’s EDGAR database contains the public filings of public US companies, including quarterly (10Q) and annual (10K) filings as well as 13F filings that list the positions held by investment-based companies at the time of each filing.
Using the MyCaffe AI Platform to analyze each of these filings, we were able to predict when a fund increased their positions with a 70% accuracy.
Reversing AI Model to discover correlations
Reversing these models revealed which data items within each filing had higher correlations with the decisions made by fund.
For example, the circled hot spot shown in the ALL 1 (buy) image (right side above) represents Lease information that we presume relates to lease information from Oil and Gas company 10Q/10K filings. As shown above, the corresponding item selected on the Excel spreadsheet relates to LesseeOperatingLeaseLiabilityPaymentDue which according to the EDGAR database is defined as:
LesseeOperatingLeaseLiabilityPaymentDue – Amount of lessee’s undiscounted obligation for lease payment for operating lease.
Each Excel spreadsheet contains thousands of similar items that show how strongly each data value contributes to the firing of a given label.
The above image hot-spot mappings were created showing how buy vs sell/hold decisions were made for all equities. However, such mappings can be created to focus on a company, sector, or industry, which may provide meaningful insights on how the objective data relates to investment decisions made.
The following hot-spot map shows the data points that triggered the sell/hold label (learned using nearly 40,000 position changes over 10 years).
Sell/Hold Hot Spots
Several notable hot-spot items impacting the decision to sell/hold a position are:
In our latest release, version 0.11.4.60, we have improved and expanded our support for Sequence-to-Sequence[1] (Seq2Seq) models with Attention[2][3], and do so with the newly released CUDA 11.4.2/cuDNN 8.2.4 from NVIDIA.
Seq2Seq Chat-bot Model
Using its drag-n-drop, visual editor, the SignalPop AI Designer now directly supports building Seq2Seq models like the one shown above. A new TEXT_DATA input layer provides easy text input management and feeds the data sequences to the model during training and testing creating a powerful visual environment for Seq2Seq!
With this release, we have also released a new Seq2Seq sample that builds on and improves the original Chat-bot sample posted during our last release.
Seq2SeqChatBot2 – in this sample, a Seq2Seq encoder/decoder model with attention is used to learn the question/response patterns of a chat-bot that allow the user to have a conversation with the Chat-bot. The model learns embeddings for the input data that are then encoded with two LSTM layers and then fed into the LSTMAttention layer along with the encoded decoder input to produce the output sequence.
The following new features have been added to this release.
CUDA 11.4.2.471/cuDNN 8.2.4.15/nvapi 470/driver 471.96
Windows 21H1, OS Build 19043.1202, SDK 10.0.19041.0
Added new TextData Layer support.
Added new Seq2Seq model support.
Added Seq2Seq model templates.
Added support for MODEL dataset type.
Enhanced weight visualization to show all weights.
Added layer inspection for EMBED layers.
Added layer inspection for LSTM layers.
Added layer inspection for LSTM_ATTENTION layers.
Added layer inspection for INNERPRODUCT layers.
Added dataset coverage analysis visualization.
Added optional load method for project exports.
Bug Fixes
Fixed bug in debug layer where data items were less than seed.
Fixed bug in error handling on Results window.
Fixed bug in network visualization blob title alignments.
Fixed bug in IMPORT.VID where image creation would stall.
Fixed bug caused when loading Getting Started document.
Fixed bug in TestMany where one class was always triggered.
Fixed bug in CreateResults where classes were not correct.
Fixed bug in TestMany when used with MULTIBOX types.
Known Issues
The following are known issues in this release.
Exporting projects to ONNX and re-importing has a known issue. To work around this issue, the weights of an ONNX model can be imported directly to a similar model.
Loading and saving LSTMAttention models using the MyCaffe weights has known issues. Instead, the learnable_blobs of the model can be loaded and saved directly.
[2] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin, Attention Is All You Need, 2017, arXiv:1706:03762.
In our latest release, version 0.11.3.25, we have added support for Sequence-to-Sequence[1] (Seq2Seq) models with Attention[2][3], and do so with the newly released CUDA 11.3/cuDNN 8.2 from NVIDIA. Seq2Seq models solve many difficult problems such as language translation, chat-bots, search and time-series prediction.
Seq2Seq model with Attention
The Seq2Seq model is made up of an Encoder (left side) that is linked to the Decoder (right side) by the Attention layer which essentially learns to map the encoder input to the decoder output. During the model processing, an embedding is learned for the encoder and decoder inputs. An encoder embedding is produced for both the encoder input and its reverse representation. These two embeddings are then fed into two LSTM layers that learn the encodings for each which are then concatenated together to produce the encoding inputs that eventually are fed to the Attention layer within the LSTMAttention layer. An embedding is also learned for the decoder inputs which are then fed to the LSTMAttention layer as well.
Within the LSTMAttention layer, the encoder encodings and last state from the LSTM Attention layer are used to produce the context for the encoding inputs. This context is then added to the LSTM cell state to produce the decoded LSTM outputs which are then run through an internal inner product and eventual softmax output. The softmax output is then used to determine the most likely word index produced which is then converted back to the word using the index-to-word mapping of the overall vocabulary. The resulting cell state is then fed back into the attention layer to produce the next context used when running the decoding LSTM on the next decoder input.
During training, the decoder input starts with the start of sequence token (e.g. ‘1’) and is followed by target0, then target1, and so on until all expected targets are processed in a teacher forcing manner.
Once training completes, the model is run by first feeding the input data through the model along with a decoder start of sequence (e.g. ‘1’) token and then the decoder half of the model is run by feeding the resulting output token back into the decoder input and continuing until an end-of-sequence token is produced. The string of word tokens produced are each converted back to their corresponding words and output as the result.
This powerful model essentially allows for learning how to map the probability distribution of one dataset to that of another.
With this release, we have also released three sample applications that use the LSTM models in three different applications.
SinCurve– In the first sample, we use the LSTM model to learn how to produce a Sin curve by training the model with teacher forcing on the Sin curve data where the previous data predicts the next data in the curve.
ImagetoSign – in the next sample, we use the LSTM model to learn to match hand drawn character images from the MNIST dataset, shown in sequence, to then draw different portions of the Sin curve. The second to last inner product data from the MNIST model is input into the LSTM model which then learns to produce a segment of the Sin curve based on the hand written character detected.
Seq2SeqChatBot – in this sample, a Seq2Seq encoder/decoder model with attention is used to learn the question/response patterns of a chat-bot that allow the user to have a conversation with the Chat-bot. The model learns embeddings for the input data that are then encoded with two LSTM layers and then fed into the LSTMAttention layer along with the encoded decoder input to produce the output sequence.
New Features
The following new features have been added to this release.
Added support for CUDA 11.3 and cuDNN 8.2 with NVAPI 650.
Tested on Windows 20H2, OS Build 19042.985, SDK 10.0.19041.0
Added ability to TestMany after a specified time.
Added signal vs. signal average comparison to Model Impact Map.
Added color separation to Model Impact Map.
Added support for visualizing custom stages from solver.prototxt.
Added new MISH layer support.
Added new HDF5_Data layer support.
Added new MAE Loss layer support.
Added new COPY layer support.
Added new LSTMAttention layer support.
Added new Seq2Seq model support with Attention.
Bug Fixes
Fixed bug in RNN learning where weights are now loaded correctly.
Fixed bugs related to accuracy calculation in RNN’s.
Fixed bug causing UI to lockup when multiple tasks were run.
Fixed bug in Copy Dataset creator where start and end dates are now used.
Fixed crash occurring after out of memory errors on application exit.
Fixed crash caused when importing weights with missing import directory.
Fixed bug where InnerProduct transpose parameter was not parsed correctly.
Fixed bug in concat_dim, now set to uint?, and ignored when null.
Improved physical database query times.
Known Issues
The following are known issues in this release.
Exporting projects to ONNX and re-importing has a known issue. To work around this issue, the weights of an ONNX model can be imported directly to a similar model.
Loading and saving LSTMAttention models using the MyCaffe weights has known issues. Instead, the learnable_blobs of the model can be loaded and saved directly.
[2] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin, Attention Is All You Need, 2017, arXiv:1706:03762.
In our latest release, version 0.11.2.9, we have added a new powerful debugging technique that visually shows the areas within an image that impact the firing of each label, and do so with the newly released CUDA 11.2/cuDNN 8.1 from NVIDIA.
Model Impact Visualization
The example above shows the areas within the CIFAR-10 [1] dataset images that actually have the most impact on firing each detected label.
Unlike the label impact visualization, originally inspired by [2], the model impact visualization shows the impact of each area of the image space on all labels, whereas the label impact shows the impact on a single label.
Label Visualization of ‘Automobile’ label sample
To learn more about these debugging techniques, see the new ‘Debugging AI Solutions‘ tutorial.
New Features
The following new features have been added to this release.
Added support for CUDA 11.2 / cuDNN 8.1.
Added new Model Impact Visualization.
Added new Model Reverse Visualization.
Added new Transpose Layer.
Added new Gather Layer.
Added new Constant Layer.
Added ONNX InceptionV2 to public models.
Added support for compute/sm 3.5 through 8.0.
Added ability to reset weights in any layer.
Added ability to freeze/unfreeze learning in any layer.
Optimized project status updates.
Optimized image loading.
Bug Fixes
The following bugs have been fixed in this release.
Fixed bug related to scheduling solvers with file data.
Fixed bug related to scheduling Char-RNN projects.
Fixed bug related to reinforcement learning rewards display.
Fixed bug in model editor where nodes exceeded 32k pixel limit.
Fixed bug related to renaming data input causing failures.
For other great examples, including, Neural Style Transfer, beating ATARI Pong and creating new Shakespeare sonnets, check out our Examples page.
Over the past ten years, Graphic Processing Units (GPUs) have dominated the hardware solution space for artificial intelligence. Currently, these GPU’s are a steady staple in just about every Datacenter offering. NVIDIA and AMD, two of the largest GPU manufacturers, have ridden this wave well and increased their profits and stock prices dramatically.
However, there appears to be a new challenger on the horizon – the Field Programmable Gate Array (FPGA), which according to some, may be an even better hardware platform for AI than the GPU.
“Artificial intelligence (AI) is evolving rapidly, with new neural network models, techniques, and use cases emerging regularly. While there is no single architecture that works best for all machine and deep learning applications, FPGAs can offer distinct advantages over GPUs and other types of hardware in certain use cases” Intel [1].
“Achronix’s high-performance FPGAs, combined with GDDR6 memory, are the industry’s highest-bandwidth memory solution for accelerating machine learning workloads in data center and automotive applications. This new joint solution addresses many of the inherent challenges in deep neural networks, including storing large data sets, weight parameters and activations in memory. The underlying hardware needs to store, process and rapidly move data between the processor and memory. In addition, it needs to be programmable to allow more efficient implementations for constantly changing machine learning algorithms. Achronix’s next-generation FPGAs have been optimized to process machine learning workloads and currently are the only FPGAs that offer support for GDDR6 memory” Micron Technology [2].
“Today silicon devices (ex: FPGA / SOC / ASIC) with latest process technology node, able to accommodate massive computing elements, memories, math function with increased memory and interface bandwidth, with smaller-footprint and low power. So having a different AI accelerator topology will certainly have advantage like Responsive, Better security, Flexibility, Performance/Watts and Adoptable. This helps in deploying different network models addressing various application and use case scenarios, by having scalable artificial intelligence accelerator for network inference which eventually enable fast prototyping and customization during the deployment” HCL Technologies [3].
In addition, large acquisitions taking place recently speak to this emerging trend from GPU to FPGA.
As shown above, when the two largest GPU manufacturers (NVIDIA and AMD) make large acquisitions of large, established FPGA companies, change is in the wind.
Why Use an FPGA vs. GPU?
FPGA’s “work similarly to GPUs and their threads in CUDA” Ashwin Sing [4]. According to Sing, several benefits of using an FPGA over a GPU include: Lower power consumption, accepted in safety-critical operations, and support for custom data types all of which are ideal for embedded applications used in edge devices such as automatic driving cars.
In addition, the FPGA appears to have one very large and growing advantage over GPU solutions – Memory. As of this writing NVIDIA recently released its 3090 GPU with a whopping 24GB of memory which is a great step for AI model designers given its low sub $1500 price point. However, the amount of memory available to the GPU (or FPGA) directly translates into faster training times for large models which then push the demand for more memory on the edge devices doing the inferencing. With larger amounts of memory, the training process can use larger input image sizes along with larger batches of images during training thus increasing the overall trained image/second throughput. Larger images lead to higher image resolution which then leads to higher training accuracies.
Memory chip specialists like Micron Technologies argue “that hardware accelerators linked to higher memory densities are the best way to accelerate ‘memory bound’ AI applications” [5]. By combining a Xilinx Virtex Ultrascale+ FPGA with up to a massive 512GB of DDR4 memory, Micron is clearly demonstrating a large advantage FPGA’s appear to have over GPU’s.
FPGA AI Challenges
Currently, programming the FPGA for machine learning is complex and difficult for “the requirement for laying out and creating hardware is a large barrier to the use of FPGAs in deep learning” [4]. However specialized compilers such as the one provided by Halide, may be changing this. In 2016, Li et al. proposed “an end-to-end FPGA-based CNN accelerator with all the layers mapped on one chip so that different layers can work concurrently in a pipelined structure to increase the throughput” [6]. An idea further extended by Yang et al. in 2018, “Interstellar: Using Halide’s Scheduling Language to Analyze DNN Accelerators” [7]. According to Yang et al., their FPGA and ASIC back ends to Halide were able to “achieve similar GOPs and DSP utilization when compared against manually optimized designs.”
Compilers do help reduce the complexity, but do not eliminate it which is especially important when using an FPGA device for training an AI solution. During the training process an AI developer is often faced with the problem of diagnosing and debugging their AI model so that it trains properly on their given dataset. Solving the ‘model blow-up’ problem can be difficult without being able to actually visually analyze the data flowing from one layer to the next. In addition, network bottlenecks can be hard to locate when using a large 100+ layer network.
The visual editing and debugging capabilities of the SignalPop AI Designer coupled with the plug-n-play low level software of the MyCaffe AI Platform [8] can help dramatically reduce or eliminate these complexities.
MyCaffe AI Platform Plug-n-Play Architecture
The MyCaffe AI Platform uses a plug-n-play architecture that allows for easy separation of the AI platform (e.g. Solver, Network and Layers) from the low-level primitives that are specific to a given hardware platform (e.g. GPU or FPGA device).
MyCaffe Plug-n-Play Hardware Support
We currently use this architecture to support the various and rapidly changing versions of CUDA and cuDNN produced by NVIDIA. However, this architecture lends itself well to the future movement from the GPU to FPGA devices discussed above. And changing between hardware support is quick and easy. From within the SignalPop AI Designer, the user just selects the hardware DLL from a menu item. And when programming MyCaffe, the path to the desired hardware DLL is passed to the MyCaffeControl during initialization.
MyCaffe and FPGA
With technologies like Halide to generate much of the low-level software that runs on the FPGA, the MyCaffe plug-n-play architecture is well suited to support a new low-level DLL designed specifically for FPGA devices.
Not only does adding FPGA support expand the reach of the MyCaffe AI Platform to the potential future of AI, it does so for over 6.2 million C# developers world-wide [9].
The SignalPop AI Designer
Combining the plug-n-play design of MyCaffe with the visual editing and debugging features of The SignalPop AI Designer can dramatically reduce the complexity of building AI solutions in general and specifically can make it easier develop such solutions for FPGA devices.
Visual Editing
Typically AI models are developed either using a text-based script that describes the model, or by programmically constructing the model by linking one layer to another. The SignalPop AI Designer transforms the prototxt model descriptions (used by the original CAFFE [10] open-source platform) into a visual representation of the model that allows for easy parameter changing, one-click help, and live debugging.
Visual Model Editing
Developers can easily switch between the visual editor and text script editor and when the model is saved, the final model descriptor prototxt is produced.
Easy Transfer Learning
After constructing the AI model, developers can easily import weights from other pre-trained models for quick transfer learning.
Easy Transfer Learning
Weights can be imported from models in the ONNX or native CAFFE file formats.
Visual Model Debugging
The SignalPop AI Designer allows visualization of the trained weights, locating bottlenecks, inspecting individual layers and visualizing the data that flows between layers are all key aspects to debugging complex AI models.
Visually Inspecting Weights
By allowing easy weight visualizations, the developer can quickly see if the expected weights are loaded during training.
Identifying Layer Bottlenecks
During training, developers can optionally view the data as it flows through the network in the Debug window and observe the timing of each layers forward and backward pass thus easily showing the designer where the network’s bottlenecks are.
Visually Inspect Embeddings
Right clicking on a debug layer while training allows for easy embedding visualization using the TSNE algorithm.
Visualizing Data Flow
Right clicking on a model layer link while training allows the designer to see the actual data flowing between the layers on both the forward and backward passes.
Summary
The MyCaffe AI Platform gives the AI developer flexibility to target different hardware platforms while the SignalPop AI Designer provides an easy to use visual development environment.
Combining these two offers an AI platform uniquely suited for creating customized solutions and is perfectly positioned for future generations of FPGA AI challenges that may soon supersede the GPU solutions of today.
If you are an FPGA manufacturer searching for an AI software solution that makes AI programming easier, contact us for we would like to work with you!
In our latest release, version 0.11.1.132, we use Single-Shot Multi-Box Detection (SSD) as described in [1] to find complex patterns in high frequency financial data streams and do so with CUDA 11.1.1 and cuDNN 8.0.5 recently released by NVIDIA.
Starting with less than 100 data items, we were able to build a training data set of around 600 items which were then used to train the model to detect both up and down trends in the SPY data.
Using proprietary plug-ins to the SignalPop AI Designer, the initial training data set was created by drawing ‘boxes’ on areas within the price stream that coincided with up or down trends. Those boxes were then translated into locations within the actual data items then fed into the model for training.
After learning a small sub-set of items, the model was then able to identify new candidates that were visually inspected for accuracy and added to the training set if the patterns detected met a general criteria. Once the data set was large enough, the model was trained for a longer training period thus allowing the model to improve its overall accuracy.
How Does This Work?
Detecting Complex Patterns with Single-Shot Multi-Box
Internally, the Single-Shot Mutli-Box learns to identify the patterns within the ground-truth boxed areas within each data item in the training set. Each data item in turn contains over 36,000 data points pulled from surrounding tangential markets that lead to a greater understanding and depth of market momentum and directional change. All data items are synced across time.
During training, the algorithm sorts through millions of potential boxes areas within these data items until the model learns the best fit boxed areas that match the patterns sought. Simultaneously, the model also learns the confidence level of the learned pattern matching the desired pattern. At the top of the model, a stack of layers from the VGG16 model are used to help detect the actual patterns desired.
SSD Model
The glue that brings this model together and makes it work is the MultiBox Loss layer which learns to find the best matching patterns that fall within the ground-truth boxes originally annotated in the training set (e.g. drawn in the financial data price stream).
All together, the 105 layers making up the Single-Shot Mutli-Box algorithm creating quite complex model as shown below.
Full SSD Model
This model is already proving to be very helpful in just locating difficult to find, key patterns within very large data-sets.
New Features
The following new features have been added to this release.
CUDA 11.1.1/cuDNN 8.0.5 support added.
Upgraded all builds to .NET Framework 4.7.2
Upgraded C++ builds to SDK 10.0.19041.0
Optimized project loads by adding VerboseStatus=false as default.
Added DebugData and DebugCriteria support to SSD results.
Added resizing and cropping options to IMPORT.IMG dataset creator.
Added new button to easily activate only annotated images.
Added statistics and create support file operations to IMPORT.IMG dataset creator.
Improved folder selection on all dataset creators.
Added default ‘background’ label to IMPORT.IMG and IMPORT.VID dataset creators.
Bug Fixes
The following bugs have been fixed in this release.
Fixed bug where project would not update to the dataset dropped on it when using AnnotatedData layer.
Fixed bugs in IMPORT.IMG dataset creator.
Fixed bugs related to Dataset Creator not remembering current selection.
Fixed bugs related to running international versions of Windows 10.
Fixed bug related to adding annotated labels with duplicates.
Fixed bug in resources, removing duplicate GPU name.
Fixed bug caused when opening a project with no dataset.
Fixed bug occurring when using Label Balancing which could cause a crash.
Fixed bug caused when importing weights and locking up the dialog.
Fixed bug caused when training multiple projects at the same time with the same image database.
Fixed bugs related to setting labels on a dataset when annotating.
Fixed bugs related to opening a project with the CudaDnnDll.dll missing.
Fixed bug in TestMany when a label is detected outside the scope of labels.
For other great examples, including, Neural Style Transfer, beating ATARI Pong and creating new Shakespeare sonnets, check out our Examples page.
[1] Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg, SSD: Single Shot MultiBox Detector, arXiv:1512.02325, 2016.
In our latest release, version 0.11.1.56, we have added support for object detection using Single-Shot Multi-Box Detection (SSD) as described in [1] and do so with the newly released CUDA 11.1 and cuDNN 8.0.4!
Single-Shot Multi-Box (SSD) object detection
With SSD, one can easily and quickly detect multiple objects within images as shown above, and/or video frames as shown below.
How Does This Work?
The MyCaffe AI Platform now implements the data annotations used to locate and label each object and the new layers needed to detect them, such as the new Permute, PriorBox, MultiBoxLoss, DetectionOutput and DetectionEvaluation layers to create the fairly complex SSD model – 105 layers in all.
SSD Model Simplified
Essentially, the SSD model is a merge between the VGG16 model (used to extract image features) and the single-shot multi-box model (used to detect objects and their locations). The VGG16 layers feed into a set of layers used to detect the box locations and also into a separate set of layers used to detect the confidence levels for the object within each box. Together, the box location layers and confidence layers are fed into the MultiBoxLoss layer which then merges the confidence loss calculation with the box confidence loss calculation. When calculating the box location loss, either a Euclidean loss or smooth L1 loss is used, with the latter being the default. And, when calculating the box confidence loss, either a sigmoid cross entropy loss or softmax loss is used, with the latter being the default.
All together, this creates a pretty complex model as shown below.
Full SSD Model
After digesting this model for a bit, you will see that the following simplification shows how the various layers flow into the MultiBoxLoss layer.
SSD Up Close
Using the new SignalPop AI Designer’s annotation editor, you can now easily create new datasets to train and run the SSD model on!
To try out the SSD model for yourself, see the new SSD video tutorial which walks you through creating your own annotated dataset from an MVW video and training a new SSD model on it. Also, see the new SSD image tutorial which walks you through creating your own annotated dataset from a directory of images and training a new SSD model on them.
New Features
The following new features have been added to this release.
CUDA 11.1.0/cuDNN 8.0.4 support added.
Upgraded all builds to Visual Studio 2019.
Added SSD TestAll support showing predicted boxes and classes.
Added SSD data annotation editor for building datasets.
Added SSD results annotation selector for expanding datasets.
Added new IMPORT.VID dataset creator used to import videos.
Added ability to set default CudaDnnDll location.
Bug Fixes
The following bugs have been fixed in this release.
Fixed database transient errors with new database connection strategy used with the SignalPop Universal Miner distributed AI support.
Fixed bugs related to running on International versions of Windows 10.
Fixed bug related to double clicking on target datasets.
For other great examples, including, Neural Style Transfer, beating ATARI Pong and creating new Shakespeare sonnets, check out our Examples page.
[1] Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg, SSD: Single Shot MultiBox Detector, arXiv:1512.02325, 2016.
In our latest release, version 0.11.0.188, we now support distributed AI via the SignalPop Universal Miner, and do so with the recent CUDA 11.0.3 and cuDNN 8.0.3 release!
The SignalPop AI Designer now allows scheduling AI projects which are then loaded and trained by a separate instance of the SignalPop Universal Miner running on a remote machine.
Distributed AI
With this configuration you can now easily develop your AI projects on your development machine and then train those same projects on your remote testing machine thus freeing up your development machine for more development work.
How does this work?
When scheduling a project, the project is placed into the scheduling database where it is later picked up by the SignalPop Universal Miner for training. During training, the SignalPop Universal Miner uses the same underlying SignalPop AI Server software to train the model using the MyCaffe AI Platform and MyCaffe In-Memory Database. Upon completion, the trained weights are placed back in the scheduling database allowing the user on the development machine to copy the results back into their project.
Distributed AI Process
The following steps occur when running a distributed AI solution.
First the designer uses the SignalPop AI Designer on the Development Machine to create the dataset and work-package data (model and solver descriptors) which are stored on the local of Microsoft SQLEXPRESS, running on the same machine as the SignalPop AI Designer application.
Next, the designer uses the SignalPop AI Designer to schedule the project by adding a new work-package to the scheduling database. The work-package contains encrypted data describing the location of the dataset and work-package data to be used by the remote Testing Machine during training.
On the Testing Machine, the SignalPop Universal Miner is assigned the scheduled work-package.
Upon being assigned to the project, the SignalPop Uiversal Miner on the Testing Machine uses the SignalPop AI Server to load the work-package data and uses it to open and start training the project.
During loading of the project, the SignalPop AI Server creates an instance of MyCaffe and loads the project into it.
In addition, the SignalPop AI Server creates an instance of the MyCaffe In-Memory Database and sets its connection credentials to those specified within the scheduled work-package thus allowing the in-memory database to access the training data residing on the designers Development Machine.
After the training of the model completes, the SignalPop Universal Miner running on the Testing Machine saves the weights and state back to the developers Development Machine and then marks the work-package as completed in the scheduling database.
Back on the designer’s Development Machine, when the SignalPop AI Designer detects that the project is done, the project is displayed as completed with results. At this point the designer may copy the scheduled results from the work-package data into the projects local results residing on the local SQLEXPRESS database used by the SignalPop AI Designer.
Since both the SignalPop AI Designer and SignalPop Universal Miner both use the same SignalPop AI Server for training AI projects, the results are the as if the project were trained locally on the designer’s Development Machine.
In our latest release, version 0.11.0.65, we have added support for the TripletNet used for one-shot and k-n shot learning as described in [1][2], and do so with the newly released CUDA 11.0.2 and cuDNN 8.0.2!
The TripletNet employs three parallel networks that each learn: an anchor image, a positive image that matches the label of the anchor, and a negative image that does not match the label of the anchor. A new Data Sequence Layer feeds the correct sequence of each of these three images into the three parallel networks (anchor, positive and negative).
At the bottom of the network the Triplet Loss Layer calculates the loss to move the positive images toward the anchor image and the negative images away from it. For details on the loss gradient calculation, see [3]. During the learning process, similar images tend to group together into clusters. To see this learned separation in action, first add a Debug Layer to the ip2 layer which learns the 4 item embedding of the anchor images.
Adding a Debug Layer
The Debug Layer caches up to 1000 of the most recently learned embeddings that are passed to it during each forward pass through the network.
Next, train the TripletNet for around 2,500 iterations where it should reach around 97% accuracy. At this point the Debug Layer will have a full cache of 1000 embeddings.
Once trained, right click on the Debug Layer and select ‘Inspect Layer‘ to run the TSNE algorithm on a subset of the stored embeddings. As shown below, the TSNE algorithm demonstrates a clear separation between each of the learned embeddings for each anchor image label.
TripletNets are very effective at learning a larger dataset, even when you only have a limited number of labeled data items. For example, the 60,000 training images of MNIST can be learned up to 80% accuracy with only 30 images of each of the 10 classes of hand written characters 0-9.
To demonstrate this, we first create a small sub-set of the MNIST dataset consisting of 30 images per label for both testing and training – a total of 600 images (1% of the MNIST 60,000 training images). And of the 600 images, only 300 images are used for training (0.5% of the original set) where the remaining 300 are used for testing.
After training the model up to around 80% accuracy, we saved the weights and then replaced the 600 image dataset with the original, full 60,000/10,000 image MNIST dataset.
Next, we ran the ‘Test Many’ function on the original MNIST dataset, using the weights learned from the 600 image MNIST sub-set dataset and attained an accuracy of 80%, showing that the majority of the full MNIST dataset can be learned with a much smaller training dataset using the TripletNet model!
To try out the TripletNet for yourself, see the TripletNet tutorial which walks through the steps to train MNIST using only 1% of the original MNIST dataset.
New Features
The following new features have been added to this release.
CUDA 11.0.2/cuDNN 8.0.2 support added.
Added ONNX InceptionV1 model support to the Public Models dialog.
Added ability to remove orphaned project files from the database.
Added ability to change labels for each item within a dataset.
Added new Data Sequence Layer support.
Added new Triplet Loss Layer support.
Added new Image Import dataset creator.
Added new Auto Label to the COPY dataset creator.
Bug Fixes
The following bugs have been fixed in this release.
Fixed bugs in Public Models dialog allowing hyperlink click during download.
Fixed bugs caused when creating datasets.
Fixed bugs in project import.
For other great examples, including beating ATARI Pong, check out our Examples page.
