Update README with Android SDK Details

README.md

@@ -130,139 +130,27 @@ print(f"Generated text: {generated_text}")
 
 ### Android Usage
 
-The model can be used on Android devices using ONNX Runtime Mobile. Here's an example using Kotlin:
+We've just released an Android SDK. You can find the SDK on our [GitHub](https://github.com/ijktech/ByteGPT-Android).
 
-```kotlin
-import ai.onnxruntime.*
-import java.nio.LongBuffer
+The SDK can be included in your Android project by adding the following to your `build.gradle` file:
 
-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)
+```
+repositories {
+    maven { 
+        url = uri("https://raw.githubusercontent.com/ijktech/ByteGPT-Android/maven-repo") 
     }
 }
 
-// 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'
+    implementation("com.github.ijktech:ByteGPT-Android:1.0.9")
 }
 ```
 
-2. Place the `model_mobile.ort` file in your app's assets folder.
+
+### iOS Usage
+
+Coming Soon! 
+
 
 ## 📜 License
 📍 **CC-BY-NC-4.0**: Free for non-commercial use.