En la actualidad, las aplicaciones de visión artificial desempeñan un papel transformador en sectores como la atención sanitaria, la fabricación, la seguridad y el comercio minorista. Sin embargo, el desarrollo y la implementación de soluciones basadas en visión artificial a menudo han sido complejos y han llevado mucho tiempo. VisionAgent, desarrollado por el equipo de LandingAI/Andrew Ng, es un generador de aplicaciones de inteligencia artificial visual generativa diseñado para agilizar la creación, la iteración y la implementación de aplicaciones de visión artificial.
Con Agentic Object Detection, VisionAgent elimina la necesidad de etiquetado de datos y entrenamiento de modelos, que requieren mucho tiempo, y supera a los sistemas de detección de objetos tradicionales. Su detección basada en indicaciones de texto permite la creación rápida de prototipos y la implementación, aprovechando las capacidades de razonamiento avanzadas para obtener resultados de alta calidad y un reconocimiento versátil de objetos y escenarios complejos.
Las características clave incluyen:
- Detección basada en indicaciones de texto – No es necesario etiquetar ni capacitar
- Razonamiento avanzado Para obtener resultados precisos y de alta calidad
- Reconocimiento versátil de objetos y escenarios complejos
VisionAgent va más allá de la simple generación de código: actúa como un sistema impulsado por IA. piloto que ayuda a los desarrolladores a planificar, seleccionar herramientas, generar código e implementar soluciones basadas en visión de manera eficiente. Al aprovechar las capacidades avanzadas de IA, los desarrolladores pueden iterar tareas en cuestión de minutos en lugar de pasar semanas afinando las soluciones.
Tabla de contenidos.
Ecosistema VisionAgent
VisionAgent consta de tres componentes principales que funcionan juntos para brindar una experiencia de desarrollo perfecta:
Comprender cómo interactúan estos componentes es clave para aprovechar todo el potencial de VisionAgent.
1. Aplicación web VisionAgent
La Aplicación web VisionAgent es una plataforma intuitiva y alojada que permite a los desarrolladores crear prototipos, refinar e implementar aplicaciones de visión sin necesidad de una configuración extensa. Diseñada para facilitar su uso, esta interfaz basada en la web permite a los usuarios:
- Sube y procesa datos sin esfuerzo
- Generar y probar código de visión por computadora
- Visualizar y ajustar resultados
- Implementar soluciones como puntos finales en la nube o como aplicación optimizada
Esta aplicación web es una opción ideal para los usuarios que desean un enfoque de código bajo para experimentar con aplicaciones de visión impulsadas por IA sin lidiar con entornos de desarrollo locales complejos.
2. Biblioteca VisionAgent
La Biblioteca VisionAgent es el núcleo del marco VisionAgent. Proporciona funcionalidades esenciales que permiten a los desarrolladores crear e implementar aplicaciones de visión impulsadas por IA de manera programática. Algunas de sus características clave incluyen:
- Planificación basada en agentes: Genera múltiples soluciones y selecciona la mejor automáticamente.
- Selección y ejecución de herramientas: Selecciona dinámicamente las herramientas adecuadas para diferentes tareas de visión.
- Generación y evaluación de código: Produce implementaciones eficientes basadas en Python.
- Soporte integrado para modelos de visión: Utiliza una variedad de modelos de visión artificial para tareas como detección de objetos, clasificación de imágenes y segmentación.
- Integración local y en la nube: Permite ejecutar tareas localmente o utilizar los modelos alojados en la nube de LandingAI para lograr escalabilidad.
Para los usuarios que prefieren una interfaz basada en chat, VisionAgent también ofrece una Aplicación de chat con tecnología Streamlit para interactuar con el agente de forma más intuitiva.
3. Biblioteca de herramientas de VisionAgent
La Biblioteca de herramientas de VisionAgent es una colección de herramientas preconstruidas que funcionan con el marco VisionAgent. Estas herramientas son abstracciones basadas en Python diseñadas para ejecutar tareas específicas de visión artificial, como:
- Detección de objetos – Identifica y localiza objetos en una imagen o vídeo.
- Clasificación de imagen – Clasifica imágenes según modelos de IA entrenados.
- Lectura de códigos QR – Extrae información codificada de códigos QR.
- Conteo de artículos – Cuenta objetos en una imagen para fines de inventario o seguimiento.
Cada herramienta puede interactuar con diferentes modelos de visión a través de una registro de modelo dinámico, lo que permite a los usuarios cambiar entre varios modelos sin problemas. Además, los desarrolladores pueden Registrar herramientas personalizadas si su caso de uso no está cubierto por las soluciones existentes.
La biblioteca de herramientas no Incluye servicios de implementación pero proporciona los componentes esenciales necesarios para ejecutar modelos de visión de manera efectiva.
Evaluación comparativa
1. Categorías y enfoques
- Detección de objetos mediante inteligencia artificial (IA) – Esto entra dentro de la categoría “Agentic”.
- Microsoft Florence-2 – Categorizado como “Detección de objetos en conjunto abierto”.
- Versión 2 de Google OWL – También en la categoría “Detección de objetos en conjunto abierto”.
- Alibaba Qwen2.5-VL-7B-Instrucción – Categorizado como un “LMM” (Gran Modelo Multimodal).
2. Métricas evaluadas
Cada modelo se evalúa en función de tres métricas de rendimiento clave:
- Recordar – Mide la eficacia con la que el modelo identifica todos los objetos relevantes. Un mayor nivel de recuperación significa menos detecciones fallidas.
- Precisión – Mide la precisión de las detecciones, lo que significa menos falsos positivos.
- Puntuación F1 – Una media armónica de precisión y recuperación, que proporciona una medida equilibrada del rendimiento.
3. Comparación de desempeño
| Modelo | Recordar | Precisión | Puntuación F1 |
| AI de aterrizaje | 77.0% | 82.6% | 79.7% (más alto) |
| Microsoft Florence-2 | 43.4% | 36.6% | 39.7% |
| Versión 2 de Google OWL | 81.0% | 29.5% | 43.2% |
| Alibaba Qwen2.5-VL-7B-Instrucción | 26.0% | 54.0% | 35.1% |
4. Puntos clave
- Detección de objetos con agentes de Landing AI logró la puntuación F1 más alta (79.7%), lo que significa que equilibra la precisión y la recuperación mejor que los demás.
- Versión 2 de Google OWL tuvo la recuperación más alta (81.0%), lo que significa que detecta la mayor cantidad de objetos pero tiene menor precisión.
- Instrucciones Qwen2.5-VL-7B de Alibaba Tenía una recuperación relativamente baja pero una precisión moderada.
- Microsoft Florence-2 mostró un rendimiento menor en todas las métricas en comparación con los otros modelos.
El enfoque de Landing AI parece ofrecer el rendimiento más equilibrado y eficaz en las tareas de detección de objetos, como se refleja en su puntuación F1 más alta. Los demás modelos tienen desventajas: algunos destacan en cuanto a la capacidad de recordar, pero carecen de precisión, o viceversa.
Funcionamiento práctico de VisionAgent
VisionAgent sigue un proceso estructurado para proporcionar resultados de manera efectiva:
- Sube una imagen que quieras analizar
- Escribe una indicación (por ejemplo, “detectar personas con gafas”)
- Nuestro agente de IA analiza la imagen a fondo.
- Recibe resultados de detección en tu imagen
1. Indicación: “Detecta las verduras dentro y alrededor de la canasta”
Paso 1: conversación
Un usuario inicia una solicitud y describe la tarea de visión en lenguaje natural. VisionAgent interpreta esta solicitud y confirma la tarea.
Imagen de entrada
Conversación
“Te ayudaré a escribir el código para detectar las verduras dentro y alrededor de la canasta en la imagen. Usaré la detección de objetos para identificar varias verduras en la escena”.
Paso 2: Planificador
Primero necesito entender qué hay en la imagen y obtener sugerencias sobre cómo detectar las verduras dentro y alrededor de la canasta. Comenzaré cargando la imagen y usando claude35_vqa y las funciones de sugerencia.
Pasos de planificación
- Comprender el contenido de la imagen utilizando VQA (Preguntas y respuestas visuales).
- Generar sugerencias relevantes para el mejor enfoque de detección.
- Seleccione herramientas que se adapten a la tarea, como detección de objetos y clasificación basada en colores.
Plan de ejemplo
- Identifica todos los objetos en la imagen.
- Determinar qué objetos son vegetales.
- Diferenciar las verduras dentro y fuera de la cesta.
- Utilizar estructura de detección anidada para analizar las relaciones espaciales.
Ejecución:
image = load_image('vegetablebasket.jpg')
claude35_vqa('Can you describe this image? What vegetables do you see in and around the basket?', [image])
suggestion('How can I detect vegetables in and around the basket in this image?', [image])Observación
[claude35_vqa output]
This image shows a beautiful array of fresh vegetables arranged around and in a wicker basket. The vegetables include:
1. Fresh carrots with green tops
2. Cauliflower
3. Onions
4. Potatoes
5. Broccoli
6. Eggplant
7. Red tomatoes
8. Yellow squash/zucchini
9. Purple cabbage
10. Green bell pepper
11. Red bell pepper
12. Cucumbers
13. Fresh garlic
14. Fresh herbs (appears to be parsley)
15. Green banana peppers or chili peppers
The vegetables appear to be very fresh and vibrant in color, arranged on what looks like a wooden surface or cutting board. The composition shows a nice variety of colors, from deep purples to bright reds, oranges, and greens, making it visually appealing and suggesting a healthy, nutritious selection of produce.
[end of claude35_vqa output]
[suggestions]
1. The vegetables are both in and around a basket, so relative_position would help in determining their locations with respect to the basket as an anchor point.
2. nested_structure applies because some vegetables are nested/contained within the basket while others are arranged outside it.
3. color would be useful since the vegetables are distinctly colored (red tomatoes, orange carrots, green broccoli, purple cabbage, etc.), making color a key identifier.
4. The problem does not involve small text, grid patterns, tracking in video, comparing sizes specifically, or dealing with extremely small objects in a large image. The depth position is visible but not crucial to the detection task.
[suggestion 0]
You need to find the color of objects in the image, you can use the following code to help with this task:
import numpy as np
import cv2
color_ranges = {
"red_lower": ((0, 100, 100), (int(179 * 20 / 360), 255, 255)),
"orange": ((int(179 * 21 / 360), 100, 100), (int(179 * 50 / 360), 255, 255)),
"yellow": ((int(179 * 51 / 360), 100, 100), (int(179 * 70 / 360), 255, 255)),
"green": ((int(179 * 71 / 360), 100, 100), (int(179 * 150 / 360), 255, 255)),
"cyan": ((int(179 * 151 / 360), 100, 100), (int(179 * 180 / 360), 255, 255)),
"blue": ((int(179 * 181 / 360), 100, 100), (int(179 * 265 / 360), 255, 255)),
"purple": ((int(179 * 266 / 360), 100, 100), (int(179 * 290 / 360), 255, 255)),
"pink": ((int(179 * 291 / 360), 100, 100), (int(179 * 330 / 360), 255, 255)),
"red_upper": ((int(179 * 331 / 360), 100, 100), (179, 255, 255)),
"white": ((0, 0, 200), (179, 25, 255)),
"gray": ((0, 0, 50), (179, 50, 200)),
"black": ((0, 0, 0), (179, 255, 30)),
}
def get_color(image, color_ranges):
hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
detected_colors = {}
for color, (lower, upper) in color_ranges.items():
upper_range = np.array(upper, dtype=np.uint8)
lower_range = np.array(lower, dtype=np.uint8)
mask = cv2.inRange(hsv_image, lower_range, upper_range)
detected_pixels = cv2.countNonZero(mask)
detected_colors[color] = detected_pixels
if "red_lower" in detected_colors and "red_upper" in detected_colors:
detected_colors["red"] = detected_colors["red_lower"] + detected_colors["red_upper"]
del detected_colors["red_lower"]
del detected_colors["red_upper"]
return sorted(detected_colors, key=detected_colors.get, reverse=True)[0]
[end of suggestion 0]
[suggestion 1]
You are trying to count objects within objects, or a nested structure. You can solve this by first detecting the outer objects, then cropping the image to the bounding box of each outer object and detecting the inner objects. You can use the following code to help with this task:
all_dets = <an object detection tool>("object", image)
height, width = image.shape[:2]
def area(box):
return (box[2] - box[0]) * (box[3] - box[1])
# only check inner detections on top 25 largest outer detections
largest_dets = sorted(dets, key=lambda x: area(x["bbox"]), reverse=True)[:25]
for det in largest_dets:
x1 = int(det["bbox"][0] * width)
y1 = int(det["bbox"][1] * height)
x2 = int(det["bbox"][2] * width)
y2 = int(det["bbox"][3] * height)
crop = image[y1:y2, x1:x2]
crop_height, crop_width = crop.shape[:2]
inner_dets = <an object detection tool>("object", crop)
for inner_det in inner_dets:
x1_inner = int(inner_det["bbox"][0] * crop_width)
y1_inner = int(inner_det["bbox"][1] * crop_height)
x2_inner = int(inner_det["bbox"][2] * crop_width)
y2_inner = int(inner_det["bbox"][3] * crop_height)
bbox = [
x1 + x1_inner,
y1 + y1_inner,
x1 + x2_inner,
y1 + y2_inner,
]
norm_bbox = [
bbox[0] / width,
bbox[1] / height,
bbox[2] / width,
bbox[3] / height,
]
all_dets.append(
{
"label": inner_det["label"],
"score": inner_det["score"],
"bbox": norm_bbox,
}
)
[end of suggestion 1]
[suggestion 2]
You are trying to locate an objects relative to 'anchor' objects. The 'anchor' objects can be detected fine, but there are many of the other objects and you only want to return the ones that are located relative to the 'anchor' objects as specified by the user. You can use the following code to help with this task:
# First find a model that can detect the location of the anchor objects
anchor_dets = <a model that can detect the location of the anchor objects>("anchor object", image)
# Then find a model that can detect the location of the relative objects
relative_dets = <a model that can detect the location of the relative objects>("relative object", image)
# This will give you relative objects 'above' the anchor objects since it's the
# distance between the lower left corner of the relative object and the upper left
# corner of the anchor object. The remaining functions can be used to get the other
# relative positions.
def above_distance(box1, box2):
return (box1["bbox"][0] - box2["bbox"][0]) ** 2 + (
box1["bbox"][3] - box2["bbox"][1]
) ** 2
def below_distance(box1, box2):
return (box1["bbox"][0] - box2["bbox"][0]) ** 2 + (
box1["bbox"][1] - box2["bbox"][3]
) ** 2
def right_distance(box1, box2):
return (box1["bbox"][0] - box2["bbox"][2]) ** 2 + (
box1["bbox"][1] - box2["bbox"][1]
) ** 2
def left_distance(box1, box2):
return (box1["bbox"][2] - box2["bbox"][0]) ** 2 + (
box1["bbox"][1] - box2["bbox"][1]
) ** 2
closest_boxes = []
for anchor_det in anchor_dets:
# You can use any of the above functions to get the relative position
distances = [
(relative_det, above_distance(relative_det, anchor_det))
for relative_det in relative_dets
]
# You must grab the nearest object for each of the anchors. This line will give
# you the box directly above the anchor box (or below, left, right depending on
# the function used)
closest_box = min(distances, key=lambda x: x[1])[0]
closest_boxes.append(closest_box)
[end of suggestion 2]
[end of suggestions]
<count>9</count>Paso 3: ejecución
Los pasos planificados se ejecutan utilizando el Biblioteca VisionAgent e Biblioteca de herramientasEsto implica cargar la imagen, ejecutar modelos y generar resultados de detección.
Planificador
Según la descripción y las sugerencias de Claude, necesito detectar verduras tanto dentro como alrededor de la canasta. Este es un problema de estructura anidada en el que primero necesito detectar la canasta y luego detectar las verduras en relación con ella. Permítanme primero conseguir una herramienta que pueda detectar tanto la canasta como las verduras.
Ejemplo de código de ejecución
image = load_image('vegetablebasket.jpg')
claude35_vqa('Can you describe this image? What vegetables do you see in and around the basket?', [image])
suggestion('How can I detect vegetables in and around the basket in this image?', [image])
get_tool_for_task('Detect basket and vegetables in the image', [image])Observación y resultado final
Después de la ejecución, VisionAgent produce resultados estructurados:
- Se detectaron verduras categorizadas dentro y fuera de la cesta.
- Coordenadas del cuadro delimitador para cada verdura detectada.
- Un modelo de IA implementable que puede utilizarse para aplicaciones del mundo real.
Salida
2. Indicación: “Identifica el coche rojo en el vídeo”
Vídeo de entrada: Video Link
Paso 1: conversación
Te ayudaré a escribir el código para identificar y rastrear los autos rojos en el video. Usaré detección de objetos y filtrado basado en colores para lograr esta tarea.
Paso 2: Planificador
Primero necesito entender qué hay en el video y obtener sugerencias sobre cómo identificar un auto rojo. Extraeré algunos fotogramas y usaré claude35_vqa para describir el contenido del video y luego obtendré sugerencias.
Paso 3: ejecución
frames = extract_frames_and_timestamps('videoplayback(4).mp4', 1)
frames = [f["frame"] for f in frames]
claude35_vqa('Can you describe this video? Is there a red car in it?', frames[:5])
suggestion('How can I identify the red car in the video?', frames[:5])Observación
[claude35_vqa output]
Yes, there is a red car (#21) in this video sequence, which appears to be a NASCAR race clip showing an incident between two cars - a red #21 car and a black/gold #3 car with Winchester branding. The video shows them making contact around turn 4 of the track, with the cars getting close to each other and potentially trading paint. The sequence is labeled as "Josh Berry vs Austin Dillon" and shows what appears to be a tense racing moment between the two drivers. The text overlays indicate "WOAH TURN 4", "CONTACT", "BERRY", "A LOT", and "THERE" as the sequence progresses.
[end of claude35_vqa output]
[suggestions]
Based on the user's request to identify the red car in the video and the provided video frames, this is primarily a case of:
1. finding_features_with_video_tracking - The sequence shows a NASCAR race interaction between two cars (Josh Berry and Austin Dillon) where tracking the red #21 car through the turn and contact is key
2. color - The specific request mentions identifying the "red car", making color identification relevant
3. relative_position - The interaction between the two cars requires understanding their positions relative to each other through the turn and contact
The other categories don't apply because:
- This isn't about small text or large images
- There are no grid patterns or missing elements
- This isn't about comparing sizes or nested structures
- While there is some depth perception in racing, the request isn't specifically about determining depth position
[suggestion 0]
You need to find the color of objects in the image, you can use the following code to help with this task:
import numpy as np
import cv2
color_ranges = {
"red_lower": ((0, 100, 100), (int(179 * 20 / 360), 255, 255)),
"orange": ((int(179 * 21 / 360), 100, 100), (int(179 * 50 / 360), 255, 255)),
"yellow": ((int(179 * 51 / 360), 100, 100), (int(179 * 70 / 360), 255, 255)),
"green": ((int(179 * 71 / 360), 100, 100), (int(179 * 150 / 360), 255, 255)),
"cyan": ((int(179 * 151 / 360), 100, 100), (int(179 * 180 / 360), 255, 255)),
"blue": ((int(179 * 181 / 360), 100, 100), (int(179 * 265 / 360), 255, 255)),
"purple": ((int(179 * 266 / 360), 100, 100), (int(179 * 290 / 360), 255, 255)),
"pink": ((int(179 * 291 / 360), 100, 100), (int(179 * 330 / 360), 255, 255)),
"red_upper": ((int(179 * 331 / 360), 100, 100), (179, 255, 255)),
"white": ((0, 0, 200), (179, 25, 255)),
"gray": ((0, 0, 50), (179, 50, 200)),
"black": ((0, 0, 0), (179, 255, 30)),
}
def get_color(image, color_ranges):
hsv_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
detected_colors = {}
for color, (lower, upper) in color_ranges.items():
upper_range = np.array(upper, dtype=np.uint8)
lower_range = np.array(lower, dtype=np.uint8)
mask = cv2.inRange(hsv_image, lower_range, upper_range)
detected_pixels = cv2.countNonZero(mask)
detected_colors[color] = detected_pixels
if "red_lower" in detected_colors and "red_upper" in detected_colors:
detected_colors["red"] = detected_colors["red_lower"] + detected_colors["red_upper"]
del detected_colors["red_lower"]
del detected_colors["red_upper"]
return sorted(detected_colors, key=detected_colors.get, reverse=True)[0]
[end of suggestion 0]
[suggestion 1]
First try to solve the problem using a VQA tool before using the tracking approach for a faster and easier solution:
answer = <VQA tool to answer your question>("<your prompt here>", image)
If that does not work, you can track the objects in the video and then identify features on those objects. You need to first get a tool that can track objects in a video, and then for each object find another tool to identify the features on the object. You can use the following code to help with this task:
track_predictions = <object tracking tool>("object", video_frames)
# Step 1: go through each frame and each prediction and extract the predicted bounding boxes as crops
obj_to_info = {}
for frame, frame_predictions in zip(video_frames, track_predictions):
for obj in frame_predictions:
if obj["label"] not in obj_to_info:
obj_to_info[obj["label"]] = []
height, width = frame.shape[:2]
crop = frame[
int(obj["bbox"][1] * height) : int(obj["bbox"][3] * height),
int(obj["bbox"][0] * width) : int(obj["bbox"][2] * width),
:,
]
# For each crop use an object detection tool, VQA tool or classification tool to identify if the object contains the features you want
output = <tool to identify your feature or multiple features>("<your feature(s) here>", crop)
obj_to_info[obj["label"]].extend(output)
print(f"{len(obj_to_info)} objects tracked")
objects_with_info = set()
for infos in obj_to_info:
for info in info:
if info["label"] == "<your feature here>":
objects_with_info.add(info)
break
print(f"{len(objects_with_info)} objects with features found")
[end of suggestion 1]
[suggestion 2]
You are trying to locate an objects relative to 'anchor' objects. The 'anchor' objects can be detected fine, but there are many of the other objects and you only want to return the ones that are located relative to the 'anchor' objects as specified by the user. You can use the following code to help with this task:
# First find a model that can detect the location of the anchor objects
anchor_dets = <a model that can detect the location of the anchor objects>("anchor object", image)
# Then find a model that can detect the location of the relative objects
relative_dets = <a model that can detect the location of the relative objects>("relative object", image)
# This will give you relative objects 'above' the anchor objects since it's the
# distance between the lower left corner of the relative object and the upper left
# corner of the anchor object. The remaining functions can be used to get the other
# relative positions.
def above_distance(box1, box2):
return (box1["bbox"][0] - box2["bbox"][0]) ** 2 + (
box1["bbox"][3] - box2["bbox"][1]
) ** 2
def below_distance(box1, box2):
return (box1["bbox"][0] - box2["bbox"][0]) ** 2 + (
box1["bbox"][1] - box2["bbox"][3]
) ** 2
def right_distance(box1, box2):
return (box1["bbox"][0] - box2["bbox"][2]) ** 2 + (
box1["bbox"][1] - box2["bbox"][1]
) ** 2
def left_distance(box1, box2):
return (box1["bbox"][2] - box2["bbox"][0]) ** 2 + (
box1["bbox"][1] - box2["bbox"][1]
) ** 2
closest_boxes = []
for anchor_det in anchor_dets:
# You can use any of the above functions to get the relative position
distances = [
(relative_det, above_distance(relative_det, anchor_det))
for relative_det in relative_dets
]
# You must grab the nearest object for each of the anchors. This line will give
# you the box directly above the anchor box (or below, left, right depending on
# the function used)
closest_box = min(distances, key=lambda x: x[1])[0]
closest_boxes.append(closest_box)
[end of suggestion 2]
[end of suggestions]
<count>9</count>Planificador
Según la descripción y las sugerencias de Claude, necesito rastrear los autos que aparecen en el video e identificar el rojo. Primero, permítanme conseguir una herramienta para rastrear los autos que aparecen en el video.
Ejecución
get_tool_for_task('Track cars in a NASCAR race video', frames[:5])Salida
Conclusión
VisionAgent está transformando la forma en que los desarrolladores crean, prueban e implementan aplicaciones de visión impulsadas por IA. Al automatizar procesos tediosos y brindar herramientas listas para usar, reduce significativamente el tiempo de desarrollo y al mismo tiempo garantiza resultados de alta calidad. Ya sea que sea un investigador de IA, un desarrollador o una empresa que busca implementar soluciones de visión artificial, VisionAgent ofrece una Rápido, flexible y escalable Manera de alcanzar tus objetivos.
Con los avances continuos en IA, se espera que VisionAgent evolucione aún más, incorporando incluso modelos más potentes y expandir su ecosistema para apoyar una gama más amplia de aplicacionesAhora es el momento perfecto para explorar cómo VisionAgent puede mejorar sus proyectos de visión impulsados por IA.
Hola, soy Pankaj Singh Negi, editor sénior de contenido. Me apasiona contar historias y crear narrativas convincentes que transformen ideas en contenido impactante. Me encanta leer sobre cómo la tecnología está revolucionando nuestro estilo de vida.
- Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
- PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
- PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
- PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
- PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
- Fuente: https://www.analyticsvidhya.com/blog/2025/02/visionagent/
