Add README with project details

README.md

@@ -128,6 +128,142 @@ print(f"Generated text: {generated_text}")
 #A dinner is only available for St. Loui
 ```
 
+### Android Usage
+
+The model can be used on Android devices using ONNX Runtime Mobile. Here's an example using Kotlin:
+
+```kotlin
+import ai.onnxruntime.*
+import java.nio.LongBuffer
+
+class ByteGPTTokenizer {
+    companion object {
+        private const val PAD_TOKEN = "<pad>"
+        private const val EOS_TOKEN = "</s>"
+        private const val UNK_TOKEN = "<unk>"
+        
+        // Token IDs for special tokens
+        private const val PAD_ID = 0L
+        private const val EOS_ID = 1L
+        private const val UNK_ID = 2L
+        private const val OFFSET = 3L // Number of special tokens
+    }
+
+    fun encode(text: String): LongArray {
+        // Convert text to UTF-8 bytes and add offset
+        val bytes = text.encodeToByteArray()
+        val ids = bytes.map { (it.toInt() and 0xFF).toLong() + OFFSET }.toLongArray()
+        
+        // Add EOS token
+        return ids + EOS_ID
+    }
+
+    fun decode(ids: LongArray): String {
+        // Convert IDs back to bytes, handling special tokens
+        val bytes = ids.mapNotNull { id ->
+            when (id) {
+                PAD_ID -> null
+                EOS_ID -> null
+                UNK_ID -> null
+                else -> (id - OFFSET).toByte()
+            }
+        }.toByteArray()
+        
+        return bytes.toString(Charsets.UTF_8)
+    }
+}
+
+class ByteGPTGenerator(
+    private val context: Context,
+    private val modelPath: String = "model_mobile.ort",
+    private val maxLength: Int = 512
+) {
+    private val env = OrtEnvironment.getEnvironment()
+    private val session: OrtSession
+    private val tokenizer = ByteGPTTokenizer()
+
+    init {
+        context.assets.open(modelPath).use { modelInput ->
+            val modelBytes = modelInput.readBytes()
+            session = env.createSession(modelBytes)
+        }
+    }
+
+    fun generate(prompt: String, maxNewTokens: Int = 50, temperature: Float = 1.0f): String {
+        var currentIds = tokenizer.encode(prompt)
+
+        for (i in 0 until maxNewTokens) {
+            if (currentIds.size >= maxLength) break
+
+            // Prepare input tensor
+            val shape = longArrayOf(1, currentIds.size.toLong())
+            val tensorInput = OnnxTensor.createTensor(
+                env,
+                LongBuffer.wrap(currentIds),
+                shape
+            )
+
+            // Run inference
+            val output = session.run(
+                mapOf("input" to tensorInput),
+                setOf("output")
+            )
+
+            // Get logits for the last token
+            val logits = output[0].value as Array<Array<Array<Float>>>
+            val lastTokenLogits = logits[0].last()
+
+            // Apply temperature
+            if (temperature != 1.0f) {
+                for (j in lastTokenLogits.indices) {
+                    lastTokenLogits[j] /= temperature
+                }
+            }
+
+            // Convert to probabilities using softmax
+            val expLogits = lastTokenLogits.map { Math.exp(it.toDouble()) }
+            val sum = expLogits.sum()
+            val probs = expLogits.map { it / sum }
+
+            // Sample from distribution
+            val random = Math.random()
+            var cumsum = 0.0
+            var nextToken = 0
+            for (j in probs.indices) {
+                cumsum += probs[j]
+                if (random < cumsum) {
+                    nextToken = j
+                    break
+                }
+            }
+
+            // Append new token
+            currentIds = currentIds.plus(nextToken.toLong())
+
+            // Stop if we generate EOS
+            if (nextToken == ByteGPTTokenizer.EOS_ID) break
+        }
+
+        return tokenizer.decode(currentIds)
+    }
+}
+
+// Usage example:
+val generator = ByteGPTGenerator(context)
+val result = generator.generate("Once upon a time")
+println(result)
+```
+
+Make sure to:
+1. Add the ONNX Runtime Mobile dependency to your `build.gradle`:
+```gradle
+dependencies {
+    implementation 'com.microsoft.onnxruntime:onnxruntime-android:latest.release'
+}
+```
+
+2. Place the `model_mobile.ort` file in your app's assets folder.
+
 ## 📜 License
 📍 **CC-BY-NC-4.0**: Free for non-commercial use.