shubham0204

private fun calculateGradients( inputs : DoubleArray , predY : Double , targetY : Double ) : Array<Any> {
    val dJ_dPred = meanSquaredErrorDerivative( predY , targetY )
    val dPred_dW = inputs
    val dJ_dW = MathOps.multiplyScalar( dPred_dW , dJ_dPred )
    val dJ_dB = dJ_dPred
    return arrayOf( dJ_dW , dJ_dB )
}

private fun meanSquaredErrorDerivative( predY : Double , targetY : Double ) : Double {
    return 2 * ( predY - targetY )

shubham0204

private fun optimizeParameters( gradients : ArrayList<Array<Any>> , learningRate : Double ) {
    val weightGradientsList = ArrayList<DoubleArray>()
    for( gradient in gradients ) {
        weightGradientsList.add( gradient[0] as DoubleArray )
    }
    val weightGradients = MathOps.multidimMean( weightGradientsList.toTypedArray()  ).toDoubleArray()

    val biasGradientsList = ArrayList<Double>()
    for( gradient in gradients ) {
        biasGradientsList.add( gradient[1] as Double )

shubham0204

fun fit ( x : Array<DoubleArray> , y: DoubleArray , epochs : Int , batchSize: Int ) {
    val batches = batch( x , y , batchSize )
    for ( e in 0 until epochs ) {
        for ( batch in batches ) {
            val gradients = ArrayList<Array<Any>>()
            for ( pair in batch ) {
                val predictions = forwardPropogate( pair.first )
                gradients.add( calculateGradients( pair.first , predictions , pair.second ) )
            }
            optimizeParameters( gradients , 0.001 )

shubham0204

• On-Device Machine Learning In Android: Frameworks and Ecosystem
• Using C/C++ in Android: A Comprehensive Guide For Beginners
• Chaquopy: Using Python In Android Apps
• Deploying Scikit-Learn Models In Android Apps With ONNX ( GitHub )
• Deploying TF models on Heroku for Android ( GitHub )
• Realtime Depth Estimation In Android ( [GitHub](https://github.com/shubham0204/Realtime_MiDaS

shubham0204

model_layers = [
	tf.keras.layers.Embedding( vocab_len + 1 , output_dim=50 , input_length=input_length ) ,
	tf.keras.layers.Conv1D( 32 , kernel_size=5 , activation="relu",strides=1 , input_shape=( input_length , 50 )),
	tf.keras.layers.Conv1D( 64, kernel_size=5, activation="relu", strides=1),
	tf.keras.layers.MaxPool1D( pool_size=4 , strides=1 ),
	tf.keras.layers.Flatten(),
	tf.keras.layers.Dense( 256 , activation="relu" ),
	tf.keras.layers.Dropout( 0.5 ) ,
	tf.keras.layers.Dense(2, activation="softmax" )
]

shubham0204

new_model = tf.keras.Sequential( model.layers[ 1 : ] )
new_model.save( 'android/no_embedding_model.h5' )

converter = tf.lite.TFLiteConverter.from_keras_model_file( 'android/no_embedding_model.h5')
converter.post_training_quantize = True
tflite_buffer = converter.convert()
open( 'android/model.tflite' , 'wb' ).write( tflite_buffer )

shubham0204

model = tf.keras.models.load_model( 'models/model.h5' )
embedding_matrix = model.layers[0].get_weights()[0] # --- ( 1 )
print( 'Embedding Shape ~> {}'.format( embedding_matrix.shape ) )

# ------------ ( 2 ) ---------------------

word_index : dict = pickle.load( open( 'glove_embedding/tokenizer.pkl' , 'rb' ) ).word_index
word_index_2 = dict()
for word , index in word_index.items():
	word_index_2[ index ] = word

shubham0204

interface VocabCallback {
    fun onDataProcessed( result : HashMap<String, DoubleArray>?)
}

private inner class LoadVocabularyTask(callback: VocabCallback?) : AsyncTask<String, Void, HashMap<String, DoubleArray>?>() {

    private var callback : VocabCallback? = callback

    override fun doInBackground(vararg params: String?): HashMap<String, DoubleArray>? {
        val jsonObject = JSONObject( params[0] )

shubham0204

fun tokenize ( message : String ): Array<DoubleArray> {
    val tokens : List<String> = Tokenizer.getTokens( message ).toList()
    val tokenizedMessage = ArrayList<DoubleArray>()
    for ( part in tokens ) {
        var vector : DoubleArray? = null
        if ( embeddingData!![part] == null ) {
            vector = DoubleArray( embeddingDim!! ){ 0.0 }
        }
        else{
            vector = embeddingData!![part]

shubham0204

@Throws(IOException::class)
private fun loadModelFile(): MappedByteBuffer {
    val MODEL_ASSETS_PATH = "model.tflite"
    val assetFileDescriptor = assets.openFd(MODEL_ASSETS_PATH)
    val fileInputStream = FileInputStream(assetFileDescriptor.fileDescriptor)
    val fileChannel = fileInputStream.channel
    val startoffset = assetFileDescriptor.startOffset
    val declaredLength = assetFileDescriptor.declaredLength
    return fileChannel.map(FileChannel.MapMode.READ_ONLY, startoffset, declaredLength)
}