Eye

Qué hace el modelo

• Una sola llamada a analyze devuelve etiquetas con su confianza, tres puntuaciones (estética, conservación y portada) y las personas, mascotas y caras de la foto. La misma llamada encuentra el mejor recorte para cualquier relación de aspecto, una corrección de rotación y un embedding.
• Las etiquetas cubren el tipo de foto (captura de pantalla, recibo, documento, documento de identidad, pizarra y más), la calidad (nítida, borrosa, bokeh) y las personas (foto de grupo, retrato, todos sonriendo). Otras cubren motivos para conservar o borrar, contenido sensible y 558 escenas.
• Cada etiqueta está calibrada para que 0,5 sea el umbral recomendado y 0,9 uno estricto. Con 0,5, la etiqueta de captura de pantalla acierta el 98% de las veces, la de recibo el 100%, la de personas el 95% y la de ojos cerrados el 92%.
• Las etiquetas de escena aciertan el 88% de las veces en la mediana. Los motivos para conservar o borrar, como «olvidable» o «mal encuadre», son los menos fiables, así que úsalos como sugerencias.
• Cada cara recibe sus propias etiquetas: ojos cerrados, sonriendo, mirando a la cámara o hacia otro lado, contenta, sorprendida. Eye analiza hasta 20 caras por foto de forma predeterminada.
• Eye.duplicates, Eye.best y Eye.similar trabajan sobre toda una biblioteca: grupos de casi duplicados, opcionalmente solo de fotos tomadas con segundos de diferencia, la que se queda de un conjunto y fotos ordenadas por similitud.
• Los análisis se guardan en el mismo JSON en Swift, Kotlin y JavaScript, así que una app puede almacenarlos y filtrar después sin cargar el modelo.
• parts elige qué calcular: photo, layout, faces y sharpness. Cada parte es una o más ejecuciones del modelo, así que deja fuera lo que no necesites.
• 48 MB como Core ML para las plataformas de Apple, en el Neural Engine, y 66 MB como LiteRT para Android, Linux, Windows, Node y el navegador. El SDK descarga el modelo la primera vez que se usa y lo guarda en caché.
• En el navegador, Eye se ejecuta en la GPU mediante WebGPU cuando el navegador lo admite, y en la CPU mediante WebAssembly cuando no.

Primeros pasos

Añade clasificación de imágenes a tu app de iOS or macOS, Android or web con unas pocas líneas de código. Docs de Eye.

// Swift Package Manager
.package(url: "https://github.com/Desert-Ant-Labs/desert-ant-core.git", from: "4.0.0")
// target dependency
.product(name: "Eye", package: "desert-ant-core")

import Eye

let eye = Eye()
let photo = try await eye.analyze(contentsOf: photoURL)

if photo.has(.screenshot) || photo.has(.receipt) { archive(photo) }
if photo.has(.sensitive, .strict) { hide(photo) }
photo.scores?.aesthetic           // 0.81: better than 81% of photos
let keeper = Eye.best(of: burst)

Add Eye from Desert Ant Labs to this Swift project (iOS, macOS).

What it does: etiquetado y puntuación de fotos en el dispositivo.

SDK:

Swift (iOS, macOS)
Repo: https://github.com/Desert-Ant-Labs/desert-ant-core#readme
// Swift Package Manager
.package(url: "https://github.com/Desert-Ant-Labs/desert-ant-core.git", from: "4.0.0")
// target dependency
.product(name: "Eye", package: "desert-ant-core")

Reference:
- Model page: https://desertant.com/models/eye/
- Full catalog and other models: https://desertant.com/llms.txt

Add the SDK, then follow its README for the exact API and current version. Do not invent API names or method signatures; confirm them against the README.

// build.gradle.kts (Maven Central)
implementation("ai.desertant:eye:4.0.0")

import ai.desertant.eye.Eye
import ai.desertant.eye.Tags

Eye(context).use { eye ->
    val photo = eye.analyze(bitmap)
    if (photo.has(Tags.DOG) && !photo.has(Tags.BLURRY)) keep(photo)
    val groups = Eye.duplicates(library)
}

Add Eye from Desert Ant Labs to this Kotlin project (Android).

What it does: etiquetado y puntuación de fotos en el dispositivo.

SDK:

Kotlin (Android)
Repo: https://github.com/Desert-Ant-Labs/desert-ant-core#readme
// build.gradle.kts (Maven Central)
implementation("ai.desertant:eye:4.0.0")

Reference:
- Model page: https://desertant.com/models/eye/
- Full catalog and other models: https://desertant.com/llms.txt

Add the SDK, then follow its README for the exact API and current version. Do not invent API names or method signatures; confirm them against the README.

npm i @desert-ant-labs/eye @litertjs/core   # browser
npm i @desert-ant-labs/eye                  # Node

import { Eye, Tag } from "@desert-ant-labs/eye";

const eye = await Eye.load();
const photo = await eye.analyze(image);
if (photo.has(Tag.dog) && !photo.has(Tag.blurry)) keep(photo);
const groups = Eye.duplicates(library, { dates });

Add Eye from Desert Ant Labs to this JavaScript / TypeScript project (Web, Node.js).

What it does: etiquetado y puntuación de fotos en el dispositivo.

SDK:

JavaScript / TypeScript (Web, Node.js)
Repo: https://github.com/Desert-Ant-Labs/desert-ant-core#readme
npm i @desert-ant-labs/eye @litertjs/core   # browser
npm i @desert-ant-labs/eye                  # Node

Reference:
- Model page: https://desertant.com/models/eye/
- Full catalog and other models: https://desertant.com/llms.txt

Add the SDK, then follow its README for the exact API and current version. Do not invent API names or method signatures; confirm them against the README.

Especificaciones

Velocidad

5,5 ms por foto en el Neural Engine (Mac con M6); 41 ms con WebGPU en Chrome

Exactitud

Con el umbral de 0,5: capturas de pantalla con un 98% de precisión, recibos con un 100%, escenas con un 88% en la mediana

Etiquetas

Tipo de foto, conservar o borrar, calidad, personas, caras, contenido sensible y 558 escenas

Tamaño en el dispositivo

48 MB Core ML (Apple); 66 MB LiteRT (Android, Linux, Windows, Node, el navegador)

Plataformas

iOS 18+, macOS 15+, tvOS 18+, visionOS 2+ (Core ML); Android, Linux, Windows (LiteRT); el navegador y Node (LiteRT.js)

Preguntas frecuentes

Recursos

• Docs de Eye
• Pesos del modelo en Hugging Face
• Modelos de Swift
• Modelos de Kotlin
• Modelos de JS