¿Conoces esa sensación cuando ves una planta preciosa en la tienda pero no tienes ni idea de lo que es ni de cómo cuidarla? Eso es exactamente lo que me pasó a mí la primavera pasada, y me hizo pensar: ¿y si pudiera apuntar con mi teléfono a cualquier planta y saberlo todo sobre ella al instante?
Así que creé PlantPal, una aplicación para iOS que identifica plantas a partir de fotos y ofrece consejos de cuidado basados en inteligencia artificial. ¿Lo mejor? Todo se ejecuta en el dispositivo utilizando la búsqueda vectorial de Couchbase. No se necesita Internet, no se envían fotos a servidores, solo pura magia local de identificación de plantas.
Lo que he construido
PlantPal resultó ser toda una aventura técnica. Básicamente, es una aplicación RAG capaz de identificar plantas a partir de tu cámara y luego chatear contigo para darte instrucciones sobre su cuidado. Pero esto es lo que la diferencia de otras aplicaciones para plantas:
Todo se ejecuta localmente en tu teléfono. Apunta tu cámara a una planta serpiente, y sabrá al instante que es una planta serpiente. Pregúntale "¿con qué frecuencia debo regar esto?" y te dará consejos específicos para esa planta en concreto, todo ello sin enviar ni un solo byte a la nube.
Ah, y me las arreglé para exprimir toda la aplicación de un ridículo 800 MB a sólo 14 MB. Más sobre este desastre más adelante.
Vídeo de demostración
La pila tecnológica (o cómo aprendí a amar las bases de datos vectoriales)
Construir esta cosa requirió bastantes piezas:
-
- iOS + Swift - Obviamente, como lo quería en mi iPhone
- Búsqueda vectorial en Couchbase Lite - Esto cambió las reglas del juego para la identificación de plantas locales.
- MobileCLIP - Modelo de visión por ordenador de Apple para convertir imágenes en números
- Núcleo ML - Para ejecutar todo localmente
- Modelos de cimentación – Marco de IA en dispositivos de Apple para la funcionalidad de chat, proporcionando capacidades LLM de privacidad sin dependencias de la nube.
Toda la filosofía era "mantener todo a nivel local." Sin API en la nube, sin enviar fotos de plantas a servidores aleatorios, sin pesadillas de privacidad. Solo tú, tu teléfono y unas matemáticas muy inteligentes.
Primera parte: La búsqueda vectorial: no es tan aterradora como parece
Por qué la mayoría de las aplicaciones para plantas son un asco
Seamos sinceros: la mayoría de las aplicaciones de identificación de plantas son bastante frustrantes. Haces una foto, esperas entre 3 y 5 segundos a que se cargue en algún servidor y luego recibes un resultado que puede ser exacto o no. Además, básicamente estás enviando fotos de tus plantas de interior a quién sabe dónde.
Quería algo que funcionara al instante, como apuntar con la cámara a una planta y saber inmediatamente qué es. Sin esperas, sin necesidad de internet, sin problemas de privacidad.
Búsqueda de vectores. Lo sé, lo sé: suena muy técnico e intimidatorio. Pero en realidad es una solución bastante elegante una vez que te haces a la idea.
La magia de las incrustaciones vectoriales
Esto es lo mejor: puedes convertir cualquier imagen en una lista de números. No como valores de píxeles, sino como números significativos que representan lo que hay DENTRO de la imagen.
|
1 2 |
Rose photo → [0.1, 0.8, 0.3, ...] (512 numbers) Tulip photo → [0.9, 0.2, 0.1, ...] (512 numbers) |
Lo bonito es que plantas similares acaban teniendo números similares. Dos fotos de rosas tendrán vectores muy parecidos, mientras que una rosa y un cactus serán completamente diferentes.
Una vez que tuve esta idea, la solución se hizo obvia: ¡basta con comparar los números! Couchbase Vector Search se encarga de encontrar vectores similares de forma eficiente.
La aplicación real resultó ser sorprendentemente limpia:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
func search(image: UIImage) -> [Record] { // Turn the camera photo into numbers let embeddings = AI.shared.embeddings(for: image, attention: .zoom(factors: [1, 2])) for embedding in embeddings { let plantSearchResults = self.searchPlants(vector: embedding) if !plantSearchResults.isEmpty { return plantSearchResults } } return [] } |
Parte 2: la gran migración MobileCLIP
Cuando el Marco de Visión no era suficiente
Así que aquí es donde las cosas se pusieron interesantes. Empecé con el framework Vision de Apple porque, bueno, está integrado en iOS y parecía la elección obvia. Para mi prueba inicial con 47 fotos de plantas, funcionó perfectamente bien. Me sentía muy bien conmigo mismo.
Entonces me volví ambicioso. ¿Y si pudiera crear una base de datos con más de 15.000 especies de plantas? Fue entonces cuando todo se vino abajo.
El problema era la precisión. Cuando probé las incrustaciones de Vision en conjuntos de datos más grandes, las plantas que parecían similares se confundían entre sí. Por ejemplo, la aplicación creía que una planta serpiente era una planta ZZ, lo que no es bueno cuando se trata de dar consejos de riego.
Resulta que las incrustaciones de Vision Framework no eran lo suficientemente distintas para mi caso. Los vectores de plantas de aspecto similar estaban demasiado juntos, por lo que la aplicación no podía distinguirlos con fiabilidad.
MobileCLIP
Después de investigar un poco (y mucha frustración), descubrí MobileCLIP. Está diseñado específicamente para tareas de similitud de imágenes, y la diferencia fue de la noche al día. De repente, las plantas similares tenían incrustaciones mucho más definidas y mi precisión aumentó considerablemente.
La migración supuso un poco de trabajo -tuve que reescribir el proceso de generación de incrustaciones-, pero mereció la pena. Ahora puedo escalar con confianza a miles de especies de plantas sin que la precisión se caiga por un precipicio.
Parte 3: El desastre de los 800 MB (y cómo lo arreglé)
Cuando tu aplicación sea más grande que la mayoría de los juegos
¿Recuerdas cuando mencioné el desastre de los 800 MB? Sí, sobre eso...
Mi primera versión era absolutamente ridícula. Enviaba la base de datos de plantas completa con imágenes de alta resolución, además de múltiples modelos MobileCLIP (S0, S1, S2, BLT -porque para qué elegir, ¿verdad?), más todos los modelos de texto que pensaba que podría necesitar algún día. La aplicación tenía básicamente el tamaño de un juego AAA para móviles.
Nadie va a descargarse una aplicación de 800 MB para identificar plantas. Quiero decir, ¿lo harías?
El avance de la precomputación
Fue entonces cuando tuve lo que me gusta llamar mi momento "duh". ¿Por qué estaba generando incrustaciones para las mismas 47 plantas cada vez que se iniciaba la aplicación? Eso es... un desperdicio.
Lo que estaba haciendo (mal):
-
- Paquete de aplicaciones: Imágenes de las plantas (10MB) + Todos los modelos (800MB) = 810MB
- Cada vez que se inicia una aplicación: Generar incrustaciones para todas las plantas de referencia
- Resultado: Arranque lento, tamaño de archivo ridículo
Lo que debería haber estado haciendo:
-
- Tiempo de construcción: Generar incrustaciones una vez a partir de imágenes de plantas
- Paquete de aplicaciones: Incrustaciones precalculadas (500 KB) + 1 modelo (14 MB) = 14 MB
- Tiempo de ejecución: Generar incrustaciones sólo para las fotos nuevas de la cámara
- Resultado: Inicio instantáneo, aplicación de tamaño normal
Aquí está el cargador de incrustación precalculado:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
class BuildTimeEmbeddingLoader { private var preComputedEmbeddings: [String: PreComputedPlantEmbedding] = [:] func loadPreComputedEmbeddings() { guard let embeddingsURL = Bundle.main.url(forResource: "plant_embeddings", withExtension: "json"), let data = try? Data(contentsOf: embeddingsURL), let embeddings = try? JSONDecoder().decode([PreComputedPlantEmbedding].self, from: data) else { return } // Load 47 plants × 512 dimensions = ~500KB total for embedding in embeddings { preComputedEmbeddings[embedding.plantId] = embedding } print(" Loaded \(embeddings.count) plants!") } } |
Ventajas:
-
- Inicio instantáneo de la aplicación: No es necesario generar incrustaciones
- 98% almacenamiento más pequeño: Incrustaciones frente a imágenes
- Mayor duración de la batería: Menos cálculos en tiempo de ejecución
Parte 4: hacer que Couchbase haga el trabajo pesado
Configuración de la base de datos (más fácil de lo que esperaba)
Seré sincero: cuando oí por primera vez "base de datos vectorial", pensé que sería algo enorme y complicado. Pero Couchbase Lite lo hizo sorprendentemente sencillo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// Enable vector search extension try! CouchbaseLiteSwift.Extension.enableVectorSearch() // Create local database let database = try! CouchbaseLiteSwift.Database(name: "plantpal") let collection = try! database.defaultCollection() // Vector index for 512-dimensional plant embeddings (MobileCLIP S1 model output size) // VectorIndexConfiguration defines index parameters: data expression, vector dimensions, clustering centroids, and distance metrics var imageVectorIndex = VectorIndexConfiguration(expression: "image", dimensions: 512, centroids: 8) imageVectorIndex.metric = .cosine imageVectorIndex.isLazy = true try! collection.createIndex(withName: "ImageVectorIndex", config: imageVectorIndex) // Full-text search for plant names let ftsIndex = FullTextIndexConfiguration(["name", "scientificName"]) try! collection.createIndex(withName: "PlantNameIndex", config: ftsIndex) print(" Vector search database ready!") |
El SQL++ que lo cambió todo
Aquí es donde Couchbase realmente brilla. En lugar de escribir complejos algoritmos de similitud, puedo usar SQL++ con una función vectorial especial. Es casi demasiado fácil:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
private func searchPlants(vector: [Float]) -> [Record] { let sql = """ SELECT type, name, scientificName, price, location, wateringSchedule, careInstructions, characteristics, APPROX_VECTOR_DISTANCE(image, $embedding) AS distance FROM _ WHERE type = "plant" AND distance BETWEEN 0 AND 0.4 ORDER BY distance, name LIMIT 1 """ let query = try collection.database.createQuery(sql) query.parameters = Parameters() .setArray(MutableArrayObject(data: vector), forName: "embedding") // Process results into Plant objects var records = [Record]() for result in try query.execute() { let plant = Plant( name: result["name"].string ?? "", scientificName: result["scientificName"].string, wateringSchedule: extractWateringSchedule(from: result), careInstructions: extractCareInstructions(from: result), characteristics: extractCharacteristics(from: result) ) records.append(plant) } return records } |
En DISTANCIA_VECTOR_APROX calcula la distancia aproximada entre un vector objetivo y los vectores de la base de datos, lo que permite una búsqueda híbrida eficaz con consultas SQL++ y compatibilidad con múltiples métricas de distancia.
Parte 5: enseñar plantas a la IA
Hacer que el chat sea realmente útil
Vale, así que podía identificar plantas. Guay. ¿Y luego qué? Quería que los usuarios pudieran hacer preguntas como "¿con qué frecuencia debo regar esto?" y obtener respuestas realmente útiles, no consejos genéricos sobre el cuidado de las plantas.
Aquí es donde entra en juego RAG (Retrieval-Augmented Generation). Básicamente, necesitaba dar a la IA un contexto específico sobre la planta que acababa de identificar. Así es como estructuré todo ese conocimiento sobre las plantas:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
class Plant: Record { let name: String? let scientificName: String? let wateringSchedule: WateringSchedule? let careInstructions: CareInstructions? let characteristics: PlantCharacteristics? struct WateringSchedule { let frequency: String let amount: String let notes: String } struct CareInstructions { let light: String let temperature: String let humidity: String let fertilizer: String let pruning: String } struct PlantCharacteristics { let toxicToPets: Bool let airPurifying: Bool let flowering: Bool let difficulty: String } } |
Cuando se identifica una planta, construyo un contexto rico para la IA a partir de datos locales:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
private func buildPlantContext(for plant: Plant) -> String { let context = """ You are PlantPal, an expert plant care assistant. You can ONLY answer questions about: \(plant.name ?? "Unknown Plant"). PLANT INFORMATION: Name: \(plant.name ?? "Unknown") Scientific Name: \(plant.scientificName ?? "Not available") WATERING SCHEDULE: \(plant.wateringSchedule?.frequency ?? "Not specified") \(plant.wateringSchedule?.notes ?? "") CARE INSTRUCTIONS: Light: \(plant.careInstructions?.light ?? "Not specified") Temperature: \(plant.careInstructions?.temperature ?? "Not specified") Humidity: \(plant.careInstructions?.humidity ?? "Not specified") CHARACTERISTICS: Pet Safe: \(plant.characteristics?.toxicToPets == false ? "Yes" : "No") Air Purifying: \(plant.characteristics?.airPurifying == true ? "Yes" : "No") Difficulty: \(plant.characteristics?.difficulty ?? "Not specified") """ return context } |
Esto proporciona respuestas de IA ricas y contextuales utilizando la información de cuidados específicos de la planta identificada.
Integración de modelos de cimentación
La función de chat aprovecha Modelos de fundación de Apple para el procesamiento del lenguaje natural en el dispositivo, lo que garantiza la privacidad de todas las conversaciones a la vez que proporciona orientación inteligente para el cuidado de las plantas mediante respuestas adaptadas al contexto.
Parte 6: optimización del rendimiento
Viaje de reducción de tamaño
-
- Empezó con: 8 modelos MobileCLIP (800 MB)
- Optimizado para: 1 modelo MobileCLIP-S1 (120 MB)
- Resultado: 85% ¡Reducción de tamaño con mayor precisión!
Parte 7: Lo que aprendí (por las malas)
Cosas que realmente funcionaron
-
- Incrustaciones precalculadas - Este ha sido probablemente mi mayor logro. Pasar de generar incrustaciones en cada inicio a precomputarlas me ha ahorrado tiempo de inicio y 98% del tamaño de la aplicación.
- MobileCLIP - Mucho mejor que Vision framework para distinguir entre plantas similares. Merece totalmente la pena el dolor de cabeza de la migración.
- Búsqueda vectorial en Couchbase - Disponer de SQL para operaciones vectoriales cambia las reglas del juego. Se acabó escribir algoritmos de similitud personalizados.
- Todo a nivel local - A los usuarios les encanta no tener que preocuparse por la conectividad a Internet o la privacidad.
Cosas que no salieron bien
-
- Optimización del tamaño del modelo - Pasé por demasiadas iteraciones tratando de encontrar el equilibrio adecuado entre la precisión y el tamaño del archivo. Enviar 8 modelos diferentes no fue... inteligente.
- Umbrales de similitud - Tardé una eternidad en afinarlos correctamente. Demasiado estricto y nada coincide, demasiado flojo y todo coincide.
- Automatización de edificios - Configurar el proceso de generación de incrustaciones para que se ejecute durante la compilación ha sido más complicado de lo esperado.
Si volviera a empezar
-
- Piense en el tamaño de la aplicación desde el primer día - No envíes aplicaciones de 800 MB, la gente no las descargará
- Pruebe su modelo de integración a escala - Lo que funciona para 50 plantas puede no funcionar para 5.000.
- Couchbase Vector Search es tu amigo - No reinvente la comparación de similitudes vectoriales
- Optimización en tiempo de compilación > optimización en tiempo de ejecución - Hacer el trabajo pesado durante la construcción, no cuando los usuarios están esperando
- Los datos reales lo revelan todo - Tu algoritmo puede funcionar perfectamente con imágenes de prueba y fallar por completo con las fotos reales de los usuarios.
¿Y ahora qué?
-
- Ampliación a más especies vegetales
- Añadir recordatorios para el cuidado de las plantas y seguimiento del progreso
- Funciones comunitarias para compartir plantas
Conclusión
Construir PlantPal resultó ser mucho más educativo de lo que esperaba. Empecé pensando "¿qué tan difícil puede ser identificar una planta?" y terminé con un profundo conocimiento de las bases de datos vectoriales, los modelos de incrustación y el arte de la optimización móvil.
¿Y lo mejor? Ahora puedo apuntar con mi teléfono a cualquier planta y saber al instante de qué planta se trata y cómo cuidarla. No hace falta Internet, no hay problemas de privacidad, es pura magia local.
Lo que más me enorgullece:
-
- De una monstruosidad de 800 MB a una elegante aplicación de 14 MB
- Respuestas instantáneas con precomputación inteligente
- Construir algo que funcione de forma fiable en el mundo real
- Demostrar que la IA compleja no necesita servidores en la nube
La búsqueda vectorial resultó ser el punto perfecto entre simplicidad y potencia. Couchbase me lo puso mucho más fácil de lo que pensaba: poder usar SQL para operaciones vectoriales es casi como hacer trampas.
Si estás pensando en crear algo similar, empieza poco a poco e itera. Mi primera versión era terrible, pero cada iteración me enseñó algo nuevo. Y, por supuesto, no lances una aplicación de 800 MB en tu primer intento. Créeme.
¿Has construido algo con búsqueda vectorial? Me encantaría que me lo contaras. Y si intentas crear tu propia aplicación de identificación de plantas, ponte en contacto conmigo: siempre tengo curiosidad por ver qué inventan los demás.
Recursos:
