Image Classification - Deck of Cards - BrainChip Akida - Edge Learning - Classifier

Brainchip / Image Classification - Deck of Cards - BrainChip Akida - Edge Learning Public

Target: BrainChip AKD1000 MINI PCIe Board Clone this project

Neural Network settings

Training settings

Number of training cycles

Please provide a valid number of training cycles (numeric only)

Learning rate

Please provide a valid number for the learning rate (between 0 and 1)

Training processor

Please provide a valid training processor option

Advanced training settings

Validation set size

Please provide a valid number for the train/validate split (between 0 and 1)

Split train/validation set on metadata key

Batch size

Auto-weight classes

Profile int8 model

Neural network architecture

Save

import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, InputLayer, Dropout, Conv1D, Conv2D, Flatten, Reshape, MaxPooling1D, MaxPooling2D, AveragePooling2D, BatchNormalization, TimeDistributed, Permute, ReLU, Softmax from tensorflow.keras.optimizers import Adam EPOCHS = args.epochs or 10 LEARNING_RATE = args.learning_rate or 0.0005 # this controls the batch size, or you can manipulate the tf.data.Dataset objects yourself BATCH_SIZE = 32 train_dataset = train_dataset.batch(BATCH_SIZE, drop_remainder=False) validation_dataset = validation_dataset.batch(BATCH_SIZE, drop_remainder=False) # model architecture model = Sequential() model.add(Conv2D(32, kernel_size=3, strides=2, kernel_constraint=tf.keras.constraints.MaxNorm(1), padding='same')) model.add(ReLU()) model.add(Conv2D(16, kernel_size=3, strides=2, kernel_constraint=tf.keras.constraints.MaxNorm(1), padding='same')) model.add(ReLU()) model.add(Flatten()) model.add(Dropout(0.25)) model.add(Dense(classes, name='y_pred')) model.add(Softmax()) # this controls the learning rate opt = Adam(learning_rate=LEARNING_RATE, beta_1=0.9, beta_2=0.999) callbacks.append(BatchLoggerCallback(BATCH_SIZE, train_sample_count, epochs=EPOCHS)) # train the neural network model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) model.fit(train_dataset, epochs=EPOCHS, validation_data=validation_dataset, verbose=2, callbacks=callbacks) import tensorflow as tf def akida_quantize_model( keras_model, weight_quantization: int = 4, activ_quantization: int = 4, input_weight_quantization: int = 8, ): import cnn2snn print("Performing post-training quantization...") akida_model = cnn2snn.quantize( keras_model, weight_quantization=weight_quantization, activ_quantization=activ_quantization, input_weight_quantization=input_weight_quantization, ) print("Performing post-training quantization OK") print("") return akida_model def akida_perform_qat( akida_model, train_dataset: tf.data.Dataset, validation_dataset: tf.data.Dataset, optimizer: str, fine_tune_loss: str, fine_tune_metrics: "list[str]", callbacks, stopping_metric: str = "val_accuracy", fit_verbose: int = 2, qat_epochs: int = 30, ): early_stopping = tf.keras.callbacks.EarlyStopping( monitor=stopping_metric, mode="max", verbose=1, min_delta=0, patience=10, restore_best_weights=True, ) callbacks.append(early_stopping) print("Running quantization-aware training...") akida_model.compile( optimizer=optimizer, loss=fine_tune_loss, metrics=fine_tune_metrics ) akida_model.fit( train_dataset, epochs=qat_epochs, verbose=fit_verbose, validation_data=validation_dataset, callbacks=callbacks, ) print("Running quantization-aware training OK") print("") return akida_model import tensorflow as tf def build_edge_learning_model(quantized_model, X_train, train_dataset: tf.data.Dataset, validation_dataset: tf.data.Dataset, callbacks, optimizer: str, fine_tune_loss: str, fine_tune_metrics: 'list[str]', additional_classes: int, neurons_per_class: int, num_classes: int, qat_function = None): from ei_tensorflow.brainchip.model import get_akida_converted_model import cnn2snn import akida import numpy as np from math import ceil import sys print("Looking for the feature extractor") feature_extractor_type = cnn2snn.quantization_layers.QuantizedReLU feature_extractor_found = False for layer in reversed(quantized_model.layers): if isinstance(layer, feature_extractor_type): print("") print(f"The assumed feature extractor layer is: {layer.name}") print("") print("Setting feature extractor bitwidth to 1") quantized_model = cnn2snn.quantize_layer(quantized_model, layer, bitwidth=1) feature_extractor_found = True break if not feature_extractor_found: print("EI_LOG_LEVEL=error ERROR: Can't find the feature extractor! Edge Learning model can't be built.") print("EI_LOG_LEVEL=info Try to modify 'feature_extractor_type' in the Keras Expert Mode") sys.exit(1) print("Looking for the feature extractor OK") #! After quantizing feature extractor layer to 1 bit, we need to retrain the model to recover the accuracy if qat_function: print("") print("Performing quantization-aware training...") quantized_model = qat_function(akida_model=quantized_model, train_dataset=train_dataset, validation_dataset=validation_dataset, optimizer=optimizer, fine_tune_loss=fine_tune_loss, fine_tune_metrics=fine_tune_metrics, callbacks=callbacks) print("Performing quantization-aware training OK") print("") else: print("EI_LOG_LEVEL=warn WARNING: QAT function not defined! Quantized model won't be retrained!") akida_edge_model = get_akida_converted_model(quantized_model, MODEL_INPUT_SHAPE) #! Build edge learning compatible model akida_edge_model.pop_layer() layer_fc = akida.FullyConnected(name='akida_edge_layer', units=additional_classes * neurons_per_class, activation=False) akida_edge_model.add(layer_fc) print('Building edge compatible model OK') print('Compiling edge learning model') #! Calculate suggested number of weights as described in: #! https://doc.brainchipinc.com/examples/edge/plot_1_edge_learning_kws.html num_samples = ceil(0.1 * X_train.shape[0]) sparsities = akida.evaluate_sparsity(akida_edge_model, np.array(X_train[:num_samples]*255, dtype=np.uint8)) output_density = 1 - sparsities[akida_edge_model.layers[-2]] avg_spikes = akida_edge_model.layers[-2].output_dims[-1] * output_density #! Fix the number of weights to 1.2 times the average number of output spikes num_weights = int(1.2 * avg_spikes) print("===========================================") print(f"The number of weights is: {num_weights}") print("===========================================") try: akida_edge_model.compile(num_weights=num_weights, num_classes=additional_classes, learning_competition=0.1) except ValueError as err: print(f"EI_LOG_LEVEL=error ERROR: Can't compile Edge Learning model: {err}") print(f"EI_LOG_LEVEL=error ERROR: If the estimated number of weights is 0, try to increase the number of training cycles") sys.exit(1) print('Compiling edge learning model OK') print('') return akida_edge_model akida_model = akida_quantize_model(model) akida_model = akida_perform_qat( akida_model, train_dataset=train_dataset, validation_dataset=validation_dataset, optimizer=opt, fine_tune_loss='categorical_crossentropy', fine_tune_metrics=['accuracy'], callbacks=callbacks) akida_edge_model = build_edge_learning_model( quantized_model=akida_model, X_train=X_train, train_dataset=train_dataset, validation_dataset=validation_dataset, callbacks=callbacks, optimizer=opt, fine_tune_loss='categorical_crossentropy', fine_tune_metrics=['accuracy'], additional_classes=1, neurons_per_class=10, num_classes=classes, qat_function=akida_perform_qat)

Input layer (76,800 features)

2D conv / pool layer (32 filters, 3 kernel size, 1 layer)

2D conv / pool layer (16 filters, 3 kernel size, 1 layer)

Flatten layer

Dropout (rate 0.25)

Output layer (53 classes)

Model

Did you know? You have access to the full set of Keras layers through the Expert view (click on to switch),
or can even bring your own model (in PyTorch, Keras or scikit-learn).

Layer type
Dense Fully connected layer, the simplest form of a neural network layer. Use this for processed data, such as the output of a spectral analysis DSP block.
1D Convolution / pooling Learn features that take spatial information into account along a single dimension. Use this for raw data, or for DSP blocks that output spatial data, such as the MFCC block.
2D Convolution / pooling Learn features that take spatial information into account along two dimensions. Use this for raw data, or for DSP blocks that output spatial data, such as the MFCC block.
Reshape Turn one-dimensional data from a DSP block into multi-dimensional data. Use this as an input to a convolutional layer. Use this for deep learning on raw data, or to process MFCC output.
Flatten Flatten multi-dimensional data into a single dimension. You need to flatten data from a convolutional layer before returning.
Dropout Reduce the risk of a model overfitting your dataset by randomly cutting a fraction of network connections during training. Can be helpful if your model's training performance is better than its validation performance.

Complete architectures

Model	Author
Motion Recognition Enterprise Motion Recognition demo (time-series data)	Brainchip
LGBM Random Forest Classifier Professional Enterprise The LightGBM Random Forest Classifier is an efficient, gradient-boosting framework that builds multiple decision trees in parallel for robust and scalable classification tasks.	Edge Impulse Inc.
XGBoost Random Forest Classifier Professional Enterprise The XGBoost Random Forest Classifier leverages the strengths of both gradient boosting and random forest methodologies to provide a powerful, efficient, and scalable solution for classification tasks.	Edge Impulse Inc.
SVM Classifier Professional Enterprise The scikit-learn SVM classifier is a powerful algorithm that constructs a hyperplane or set of hyperplanes in a high-dimensional space for classification, effectively handling both linear and non-linear data.	Edge Impulse Inc.
Random Forest Classifier Professional Enterprise The scikit-learn Random Forest Classifier is a versatile machine learning algorithm that builds multiple decision trees and merges their predictions for robust and accurate classification.	Edge Impulse Inc.
Logistic Regression Professional Enterprise The scikit-learn Logistic Regressor is a linear model for classification that estimates probabilities using a logistic function, effectively handling binary and multiclass classification tasks.	Edge Impulse Inc.
Ridge Classifier Professional Enterprise The scikit-learn Ridge classifier employs L2 regularization to optimize a linear classification model, mitigating overfitting by penalizing large coefficients, thereby enhancing model generalizability across diverse datasets.	Edge Impulse Inc.
RidgeCV Classifier Professional Enterprise The scikit-learn RidgeCV classifier is a linear regression model with built-in cross-validation that applies ridge regularization to prevent overfitting and improve prediction accuracy.	Edge Impulse Inc.

The backbone is the foundational element of a neural network model, responsible for extracting meaningful features from input data, enabling subsequent parts to perform anomaly scoring or classification.

Description	Author
EfficientNet V2B0 Uses around 755K RAM based on your input size, and between 240-1675K ROM depending on the number of layers, with default compiler settings. Supports RGB.	Edge Impulse
MobileNetV2 0.35 Uses around 636K RAM based on your input size, and between 69-134K ROM depending on the number of layers, with default compiler settings. Supports both RGB and grayscale.	Edge Impulse
MobileNetV2 0.50 Uses around 643K RAM based on your input size, and between 78-168K ROM depending on the number of layers, with default compiler settings. Supports both RGB and grayscale.	Edge Impulse
MobileNetV2 0.75 Uses around 1263K RAM based on your input size, and between 109-266K ROM depending on the number of layers, with default compiler settings. Supports both RGB and grayscale.	Edge Impulse
MobileNetV2 1.0 Uses around 1273K RAM based on your input size, and between 126-372K ROM depending on the number of layers, with default compiler settings. Supports both RGB and grayscale.	Edge Impulse
MobileNetV2 0.1 Uses around 622K RAM based on your input size, and 58K ROM, with default compiler settings. Supports both RGB and grayscale.	Edge Impulse

The scoring function operates on the features extracted by the backbone, and returns anomaly scores for each segment of the image.

Description	Author	Recommended
Motion Recognition Motion Recognition demo (time-series data)	Edge Impulse
LGBM Random Forest Classifier The LightGBM Random Forest Classifier is an efficient, gradient-boosting framework that builds multiple decision trees in parallel for robust and scalable classification tasks.	Edge Impulse
XGBoost Random Forest Classifier The XGBoost Random Forest Classifier leverages the strengths of both gradient boosting and random forest methodologies to provide a powerful, efficient, and scalable solution for classification tasks.	Edge Impulse
SVM Classifier The scikit-learn SVM classifier is a powerful algorithm that constructs a hyperplane or set of hyperplanes in a high-dimensional space for classification, effectively handling both linear and non-linear data.	Edge Impulse
Random Forest Classifier The scikit-learn Random Forest Classifier is a versatile machine learning algorithm that builds multiple decision trees and merges their predictions for robust and accurate classification.	Edge Impulse
Logistic Regression The scikit-learn Logistic Regressor is a linear model for classification that estimates probabilities using a logistic function, effectively handling binary and multiclass classification tasks.	Edge Impulse
Ridge Classifier The scikit-learn Ridge classifier employs L2 regularization to optimize a linear classification model, mitigating overfitting by penalizing large coefficients, thereby enhancing model generalizability across diverse datasets.	Edge Impulse
RidgeCV Classifier The scikit-learn RidgeCV classifier is a linear regression model with built-in cross-validation that applies ridge regularization to prevent overfitting and improve prediction accuracy.	Edge Impulse

These users will be notified over email when this job finishes.

	Name
	Joshua Buck Edge Impulse staff

Neural Network settings

Training settings

Augmentation settings

Advanced training settings

Neural network architecture

Model