Capítulo 2: Comprensión y Generación de Audio con Whisper y GPT-4o
2.3 Comprensión del Habla en GPT-4o
En esta sección, descubrirás cómo trabajar con capacidades avanzadas de procesamiento de audio que van más allá de la transcripción básica. GPT-4o introduce un enfoque revolucionario para la comprensión del audio al permitir la integración directa de archivos de audio junto con indicaciones textuales. Esto crea un sistema de interacción multimodal fluido donde tanto las entradas de audio como de texto se procesan simultáneamente. El sistema puede analizar varios aspectos del habla, incluyendo el tono, el contexto y el significado semántico, permitiéndote construir asistentes inteligentes sofisticados que pueden escuchar, comprender y responder naturalmente dentro de cualquier contexto dado.
La tecnología representa un avance significativo en el procesamiento de audio al combinar la transcripción estilo Whisper con las capacidades avanzadas de razonamiento de GPT-4o. Mientras que Whisper sobresale en la conversión del habla a texto, GPT-4o va más allá al realizar un análisis profundo del contenido transcrito. Esta integración ocurre en una interacción fluida, eliminando la necesidad de pasos de procesamiento separados. Por ejemplo, al procesar la grabación de una reunión de negocios, GPT-4o puede simultáneamente transcribir el habla, identificar hablantes, extraer elementos de acción y generar resúmenes, todo mientras mantiene el contexto y comprende los matices sutiles en la comunicación.
Esta poderosa combinación abre posibilidades sin precedentes para crear aplicaciones de IA más intuitivas y receptivas. Estas aplicaciones no solo pueden procesar y comprender el lenguaje hablado, sino que también pueden interpretar el contexto, la emoción y la intención de formas que anteriormente no eran posibles. Ya sea analizando llamadas de servicio al cliente, procesando conferencias educativas o facilitando la comunicación multilingüe, el sistema proporciona una comprensión integral del contenido hablado que va mucho más allá de la simple transcripción.
2.3.1 ¿Por qué GPT-4o para el Habla?
Mientras que la API de Whisper sobresale en convertir el lenguaje hablado en texto escrito, GPT-4o representa un salto revolucionario en las capacidades de procesamiento de audio. Para entender la distinción, imagina a Whisper como un transcriptor altamente capacitado que puede escribir con precisión cada palabra hablada, mientras que GPT-4o funciona más como un analista experimentado con una profunda comprensión contextual.
Las capacidades de GPT-4o se extienden mucho más allá de la transcripción básica. Puede comprender y procesar el habla en múltiples niveles simultáneamente:
Comprensión Semántica
Comprende el significado real detrás de las palabras, yendo más allá de la traducción palabra por palabra. Esta capacidad avanzada permite a GPT-4o procesar el lenguaje en múltiples niveles simultáneamente, entendiendo no solo el significado literal sino también las capas semánticas más profundas, el contexto cultural y el mensaje pretendido. Esto incluye la comprensión de modismos, metáforas, referencias culturales y expresiones regionales dentro del habla, así como la detección de matices sutiles en la comunicación que podrían perderse en una simple transcripción.
Por ejemplo, cuando alguien dice "está lloviendo a cántaros", GPT-4o entiende que significa una lluvia intensa en lugar de interpretar literalmente que caen cántaros del cielo. De manera similar, al procesar frases como "mucha mierda" antes de una actuación o "pan comido" para describir una tarea fácil, el sistema interpreta correctamente estas expresiones idiomáticas dentro de su contexto cultural.
También puede captar conceptos complejos como el sarcasmo ("Oh, genial, otra reunión"), el humor ("¿Por qué cruzó el modelo GPT la calle?"), y preguntas retóricas ("¿Quién no querría eso?"), haciéndolo capaz de comprender verdaderamente la comunicación humana en todo su contexto. Esta comprensión sofisticada se extiende a referencias culturales específicas, jerga profesional e incluso variaciones dialectales regionales, asegurando una interpretación precisa independientemente del origen o estilo de comunicación del hablante.
Ejemplo:
Dado que la interacción estándar de la API de OpenAI para esto típicamente involucra primero convertir el habla a texto (usando Whisper) y después analizar ese texto para un significado más profundo (usando GPT-4o), el ejemplo de código demostrará este proceso de dos pasos.
Este script:
- Transcribirá un archivo de audio que contiene lenguaje potencialmente matizado usando Whisper.
- Enviará el texto transcrito a GPT-4o con una indicación solicitando interpretación semántica.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/idiom_speech.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:37 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-04-21 19:37:00 CDT"
current_location = "Dallas, Texas, United States"
print(f"Running GPT-4o semantic speech understanding example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with nuanced speech
# IMPORTANT: Replace 'idiom_speech.mp3' with the actual filename.
# Good examples for audio content: "Wow, that presentation just knocked my socks off!",
# "Sure, I'd LOVE to attend another three-hour meeting.", "He really spilled the beans."
audio_file_path = "idiom_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Text for Semantic Meaning using GPT-4o ---
def analyze_text_meaning(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for semantic analysis."""
print(f"\nStep 2: Analyzing text for semantic meaning: \"{text_to_analyze}\"")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Construct prompt to ask for deeper meaning
system_prompt = "You are an expert in linguistics and communication."
user_prompt = (
f"Analyze the following phrase or sentence:\n\n'{text_to_analyze}'\n\n"
"Explain its likely intended meaning, considering context, idioms, "
"metaphors, sarcasm, humor, cultural references, or other nuances. "
"Go beyond a literal, word-for-word interpretation."
)
try:
print("Sending text to GPT-4o for analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for its strong understanding capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=250, # Adjust as needed
temperature=0.5 # Lower temperature for more focused analysis
)
analysis = response.choices[0].message.content
print("Semantic analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\nTranscription Result: {transcribed_text}")
# Step 2: Analyze the transcription for meaning
semantic_analysis = analyze_text_meaning(client, transcribed_text)
if semantic_analysis:
print("\n--- Semantic Analysis Result ---")
print(semantic_analysis)
print("--------------------------------\n")
print("This demonstrates GPT-4o understanding nuances beyond literal text.")
else:
print("\nSemantic analysis failed.")
else:
print("\nTranscription failed, cannot proceed to analysis.")Desglose del código:
- Contexto: Este código demuestra la comprensión semántica avanzada del habla de GPT-4o. Va más allá de la simple transcripción al interpretar el significado, incluyendo matices como modismos, sarcasmo o frases dependientes del contexto.
- Proceso en dos pasos: El ejemplo utiliza un enfoque estándar de API en dos etapas:
- Paso 1 (Whisper): El archivo de audio se convierte primero en texto utilizando la API de Whisper (
client.audio.transcriptions.create). Esto captura las palabras habladas con precisión. - Paso 2 (GPT-4o): El texto transcrito se envía luego al modelo GPT-4o (
client.chat.completions.create) con una instrucción específica solicitando el análisis del significado detrás de las palabras, considerando interpretaciones no literales.
- Paso 1 (Whisper): El archivo de audio se convierte primero en texto utilizando la API de Whisper (
- Requisitos previos: Requiere la configuración estándar de
openaiypython-dotenv, clave API y, fundamentalmente, un archivo de audio que contenga habla con ciertos matices (por ejemplo, que incluya un modismo como "poner las cartas sobre la mesa", un comentario sarcástico como "Qué bien, otra reunión", o una frase culturalmente específica). - Función de transcripción (
transcribe_speech): Esta función maneja el Paso 1, tomando la ruta del archivo de audio y devolviendo la transcripción en texto plano de Whisper. - Función de análisis semántico (
analyze_text_meaning):- Esta función maneja el Paso 2. Recibe el texto transcrito.
- Diseño de la instrucción: Construye una instrucción específicamente pidiendo a GPT-4o que actúe como experto lingüístico y explique el significado pretendido, considerando modismos, sarcasmo, contexto, etc., solicitando explícitamente un análisis más allá de la interpretación literal.
- Utiliza
gpt-4ocomo modelo por sus sólidas capacidades de razonamiento y comprensión. - Devuelve el análisis proporcionado por GPT-4o.
- Ejecución principal: El script primero transcribe el audio. Si tiene éxito, pasa el texto a la función de análisis. Finalmente, imprime tanto la transcripción literal como la interpretación semántica de GPT-4o.
- Relevancia del caso de uso: Este ejemplo muestra claramente cómo la combinación de Whisper y GPT-4o permite una comprensión más profunda del lenguaje hablado que la simple transcripción. Demuestra la capacidad descrita – comprender modismos ("llover a cántaros"), sarcasmo, humor y contexto – haciendo que la interacción con la IA esté más alineada con la comunicación humana.
Recuerda usar un archivo de audio que contenga lenguaje no literal para las pruebas para mostrar mejor el paso de análisis semántico. Reemplaza 'idiom_speech.mp3' con tu ruta de archivo real.
Análisis Contextual
Interpreta las declaraciones dentro de su contexto más amplio, teniendo en cuenta la información circundante, discusiones previas, referencias culturales y factores situacionales. Esto incluye entender cómo el tiempo, lugar, relaciones entre hablantes y conversaciones previas influyen en el significado. El análisis considera múltiples capas de contexto:
- Contexto temporal: Cuándo se dice algo (hora del día, día de la semana, temporada o período histórico)
- Contexto social: Las relaciones entre hablantes, dinámicas de poder y normas sociales
- Contexto físico: La ubicación y el entorno donde ocurre la comunicación
- Contexto cultural: Conocimientos, creencias y costumbres compartidas que influyen en la interpretación
Por ejemplo, la frase "se está haciendo tarde" podría significar diferentes cosas en diferentes contextos:
- Durante una reunión de trabajo: Una sugerencia cortés para concluir la discusión
- En una reunión social: Una indicación de que alguien necesita irse
- De un padre a un hijo: Un recordatorio sobre la hora de dormir
- En una discusión de proyecto: Preocupación por plazos que se aproximan
GPT-4o analiza estas pistas contextuales junto con factores adicionales como el tono de voz, patrones de habla e historial de conversación para proporcionar interpretaciones más precisas y matizadas de la comunicación hablada. Esta comprensión contextual profunda permite al sistema captar el verdadero significado pretendido detrás de las palabras, más allá de su interpretación literal.
Ejemplo:
Este caso de uso se centra en la capacidad de GPT-4o para interpretar el habla transcrita dentro de su contexto más amplio (temporal, social, físico, cultural). Como en el ejemplo de comprensión semántica, esto típicamente involucra un proceso de dos pasos: transcribir el habla con Whisper, luego analizar el texto con GPT-4o, pero esta vez proporcionando explícitamente información contextual a GPT-4o.
Este ejemplo de código:
- Transcribirá una frase simple dependiente del contexto desde un archivo de audio usando Whisper.
- Enviará el texto transcrito a GPT-4o múltiples veces, cada vez proporcionando un contexto diferente.
- Mostrará cómo la interpretación de GPT-4o de la misma frase cambia según el contexto proporcionado.
Descarga el audio de ejemplo: https://files.cuantum.tech/audio/context_phrase.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:44 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-02-11 11:44:00 CDT" # Updated time
current_location = "Miami, Florida, United States"
print(f"Running GPT-4o contextual speech analysis example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with the context-dependent phrase
# IMPORTANT: Replace 'context_phrase.mp3' with the actual filename.
# The audio content should ideally be just "It's getting late."
audio_file_path = "context_phrase.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from the previous example (gpt4o_speech_semantic_py)
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Text for Meaning WITHIN a Given Context using GPT-4o ---
def analyze_text_with_context(client, text_to_analyze, context_description):
"""Sends transcribed text and context description to GPT-4o for analysis."""
print(f"\nStep 2: Analyzing text \"{text_to_analyze}\" within context...")
print(f"Context Provided: {context_description}")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
if not context_description:
print("Error: Context description must be provided for this analysis.")
return None
# Construct prompt asking for interpretation based on context
system_prompt = "You are an expert in analyzing communication and understanding context."
user_prompt = (
f"Consider the phrase: '{text_to_analyze}'\n\n"
f"Now, consider the specific context in which it was said: '{context_description}'\n\n"
"Based *only* on this context, explain the likely intended meaning, implication, "
"or function of the phrase in this situation."
)
try:
print("Sending text and context to GPT-4o for analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong contextual reasoning
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=200, # Adjust as needed
temperature=0.3 # Lower temperature for more focused contextual interpretation
)
analysis = response.choices[0].message.content
print("Contextual analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio phrase
transcribed_phrase = transcribe_speech(client, audio_file_path)
if transcribed_phrase:
print(f"\nTranscription Result: \"{transcribed_phrase}\"")
# Define different contexts for the same phrase
contexts = [
"Said during a business meeting scheduled to end at 5:00 PM, spoken at 4:55 PM.",
"Said by a guest at a social party around 1:00 AM.",
"Said by a parent to a young child at 9:00 PM on a school night.",
"Said during a critical project discussion about an upcoming deadline, spoken late in the evening.",
"Said by someone looking out the window on a short winter afternoon."
]
print("\n--- Analyzing Phrase in Different Contexts ---")
# Step 2: Analyze the phrase within each context
for i, context in enumerate(contexts):
print(f"\n--- Analysis for Context {i+1} ---")
contextual_meaning = analyze_text_with_context(
client,
transcribed_phrase,
context
)
if contextual_meaning:
print(f"Meaning in Context: {contextual_meaning}")
else:
print("Contextual analysis failed for this context.")
print("------------------------------------")
print("\nThis demonstrates how GPT-4o interprets the same phrase differently based on provided context.")
else:
print("\nTranscription failed, cannot proceed to contextual analysis.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para el análisis contextual del habla. Muestra cómo la interpretación de una frase hablada puede cambiar drásticamente según la situación circundante (factores temporales, sociales y situacionales).
- Proceso de dos pasos con inyección de contexto:
- Paso 1 (Whisper): El archivo de audio que contiene una frase dependiente del contexto (por ejemplo, "Se está haciendo tarde") se transcribe a texto usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): El texto transcrito se envía entonces a GPT-4o (
client.chat.completions.create), pero de manera crucial, el prompt ahora incluye una descripción del contexto específico en el que se pronunció la frase.
- Paso 1 (Whisper): El archivo de audio que contiene una frase dependiente del contexto (por ejemplo, "Se está haciendo tarde") se transcribe a texto usando
- Requisitos previos: Requiere la configuración estándar de
openaiypython-dotenv, clave API, y un archivo de audio que contenga una frase simple cuyo significado dependa en gran medida del contexto (el ejemplo usa "Se está haciendo tarde"). - Función de transcripción (
transcribe_speech): Esta función (reutilizada del ejemplo anterior) maneja el Paso 1. - Función de análisis contextual (
analyze_text_with_context):- Esta función maneja el Paso 2 y ahora acepta un argumento adicional:
context_description. - Diseño del prompt: El prompt proporciona explícitamente tanto la frase transcrita como la
context_descriptiona GPT-4o, pidiéndole que interprete la frase dentro de esa situación específica. - Utiliza
gpt-4opor su capacidad de razonar basándose en el contexto proporcionado.
- Esta función maneja el Paso 2 y ahora acepta un argumento adicional:
- Demostración de la dependencia del contexto (Ejecución principal):
- El script primero transcribe la frase (por ejemplo, "Se está haciendo tarde").
- Luego define una lista de diferentes descripciones de contexto (finalización de reunión, fiesta nocturna, hora de dormir, fecha límite de proyecto, día corto de invierno).
- Llama a la función
analyze_text_with_contextrepetidamente, usando la misma frase transcrita pero proporcionando una descripción de contexto diferente cada vez. - Al imprimir el resultado del análisis para cada contexto, el script muestra claramente cómo la interpretación de GPT-4o cambia según el contexto proporcionado (por ejemplo, sugiriendo concluir vs. indicando cansancio vs. notando la disminución de la luz del día).
- Relevancia del caso de uso: Esto destaca la comprensión sofisticada de GPT-4o, yendo más allá de las palabras literales para captar el significado pretendido influenciado por factores temporales, sociales y situacionales. Esto es vital para aplicaciones que necesitan una interpretación precisa de la comunicación en el mundo real en negocios, interacciones sociales o cualquier entorno rico en contexto. Muestra cómo los desarrolladores pueden proporcionar contexto relevante junto con el texto transcrito para obtener interpretaciones más precisas y matizadas de la IA.
Para probar este código efectivamente, crea un archivo de audio que contenga solo la frase "Se está haciendo tarde" (u otra frase dependiente del contexto), o descarga el archivo de muestra proporcionado. Recuerda actualizar la ruta 'context_phrase.mp3' para que coincida con la ubicación de tu archivo.
Generación de resúmenes
Las capacidades de generación de resúmenes de GPT-4o representan un avance significativo en el análisis de contenido impulsado por IA. El sistema crea resúmenes concisos y significativos de discusiones complejas mediante la destilación inteligente de información clave de conversaciones, reuniones o presentaciones extensas. Utilizando procesamiento avanzado del lenguaje natural y comprensión contextual, GPT-4o puede identificar temas principales, puntos críticos y conclusiones esenciales mientras mantiene el significado central y el contexto de la discusión original.
El sistema emplea varias técnicas sofisticadas:
- Reconocimiento de patrones: Identifica temas recurrentes y puntos importantes de discusión a lo largo de conversaciones extensas
- Análisis contextual: Comprende el contexto más amplio y las relaciones entre diferentes partes de la discusión
- Detección de prioridades: Determina automáticamente qué información es más crucial para el resumen
- Comprensión semántica: Capta significados subyacentes e implicaciones más allá del contenido superficial
Los resúmenes generados pueden personalizarse para diferentes propósitos y audiencias:
- Informes ejecutivos: Enfocados en perspectivas estratégicas y decisiones de alto nivel
- Actas de reuniones: Documentación detallada de discusiones y elementos de acción
- Resúmenes rápidos: Aspectos destacados condensados para consumo rápido de información
- Resúmenes técnicos: Énfasis en detalles técnicos específicos y especificaciones
Lo que distingue a GPT-4o es su capacidad para preservar detalles importantes mientras reduce significativamente la sobrecarga de información, convirtiéndolo en una herramienta invaluable para la comunicación empresarial moderna y la gestión del conocimiento.
Ejemplo:
Este ejemplo se centra en la capacidad de GPT-4o para generar resúmenes concisos y significativos de contenido hablado potencialmente extenso obtenido a través de Whisper.
Esto involucra el proceso familiar de dos pasos: primero, transcribir el audio con Whisper para obtener el texto completo, y segundo, usar las capacidades de comprensión del lenguaje de GPT-4o para analizar y resumir ese texto según necesidades específicas. Este ejemplo demostrará la generación de diferentes tipos de resúmenes a partir de la misma transcripción.
Descarga el audio de muestra: https://files.cuantum.tech/audio/discussion_audio.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:59 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-04-10 15:59:00 CDT" # Updated time
current_location = "Houston, Texas, United States"
print(f"Running GPT-4o speech summarization example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'discussion_audio.mp3' with the actual filename.
audio_file_path = "discussion_audio.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before summarization.")
except OSError:
pass # Ignore size check error, proceed with transcription attempt
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Generate Summary from Text using GPT-4o ---
def summarize_text(client, text_to_summarize, summary_style="concise overview"):
"""Sends transcribed text to GPT-4o for summarization."""
print(f"\nStep 2: Generating '{summary_style}' summary...")
if not text_to_summarize:
print("Error: No text provided for summarization.")
return None
# Tailor the prompt based on the desired summary style
system_prompt = "You are an expert meeting summarizer and information distiller."
user_prompt = f"""Please generate a {summary_style} of the following discussion transcription.
Focus on accurately capturing the key information relevant to a {summary_style}. For example:
- For an 'executive briefing', focus on strategic points, decisions, and outcomes.
- For 'detailed meeting minutes', include main topics, key arguments, decisions, and action items.
- For a 'concise overview', provide the absolute main points and purpose.
- For a 'technical summary', emphasize technical details, specifications, or findings.
Transcription Text:
---
{text_to_summarize}
---
Generate the {summary_style}:
"""
try:
print(f"Sending text to GPT-4o for {summary_style}...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong summarization
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=400, # Adjust based on expected summary length
temperature=0.5 # Balance creativity and focus
)
summary = response.choices[0].message.content
print(f"'{summary_style}' generation successful.")
return summary.strip()
except OpenAIError as e:
print(f"OpenAI API Error during summarization: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during summarization: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("--------------------------")
# Step 2: Generate summaries in different styles
summary_styles_to_generate = [
"concise overview",
"detailed meeting minutes with action items",
"executive briefing focusing on decisions",
# "technical summary" # Add if relevant to your audio content
]
print("\n--- Generating Summaries ---")
for style in summary_styles_to_generate:
print(f"\n--- Summary Style: {style} ---")
summary_result = summarize_text(
client,
full_transcription,
summary_style=style
)
if summary_result:
print(summary_result)
else:
print(f"Failed to generate '{style}'.")
print("------------------------------------")
print("\nThis demonstrates GPT-4o generating different summaries from the same transcription based on the prompt.")
else:
print("\nTranscription failed, cannot proceed to summarization.")Desglose del código:
- Contexto: Este código demuestra la capacidad avanzada de GPT-4o para generar resúmenes de contenido hablado. Utiliza un proceso de dos pasos: transcribir el audio con Whisper y luego usar GPT-4o para destilar inteligentemente la información clave de la transcripción en un resumen conciso.
- Manejo de Audio Extenso (Nota Crucial): Los prerrequisitos y comentarios del código abordan explícitamente el límite de 25MB de la API de Whisper. Para reuniones o presentaciones largas del mundo real, el audio debe ser dividido en fragmentos, cada fragmento transcrito por separado, y los textos resultantes concatenados antes de ser enviados al paso de resumen. El ejemplo de código procesa un solo archivo de audio por simplicidad, pero destaca este flujo de trabajo esencial para contenido más largo.
- Prerrequisitos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que representa la discusión a resumir (discussion_audio.mp3). - Función de Transcripción (
transcribe_speech): Maneja el Paso 1, convirtiendo el audio de entrada (o fragmento de audio) en texto plano usando Whisper. - Función de Resumen (
summarize_text):- Maneja el Paso 2, tomando el texto transcrito completo como entrada.
- Resúmenes Personalizables: Acepta un argumento
summary_style(por ejemplo, "informe ejecutivo", "actas detalladas de reunión"). - Ingeniería de Prompt: El prompt enviado a GPT-4o se construye dinámicamente según el
summary_stylesolicitado. Instruye a GPT-4o para actuar como un experto en resúmenes y adaptar la salida (enfocándose en puntos estratégicos, elementos de acción, detalles técnicos, etc.) según el estilo deseado. - Utiliza
gpt-4opor sus avanzadas capacidades de comprensión y resumen.
- Demostración de Diferentes Tipos de Resumen (Ejecución Principal):
- El script primero obtiene la transcripción completa.
- Luego define una lista de diferentes
summary_styles_to_generate. - Llama a la función
summarize_textmúltiples veces, pasando la misma transcripción completa cada vez pero variando el argumentosummary_style. - Al imprimir cada resumen resultante, el script muestra claramente cómo GPT-4o adapta el nivel de detalle y enfoque según el prompt, generando salidas distintas (por ejemplo, una visión general breve vs. actas detalladas) del mismo texto fuente.
- Relevancia de Caso de Uso: Esto aborda directamente la capacidad de "Generación de Resúmenes". Muestra cómo la combinación de Whisper y GPT-4o puede transformar discusiones habladas extensas en varios formatos útiles (informes ejecutivos, actas de reuniones, resúmenes rápidos), ahorrando tiempo y mejorando la gestión del conocimiento en negocios, educación y creación de contenido.
Extracción de Puntos Clave
Identifica y destaca información crucial aprovechando las capacidades avanzadas de procesamiento del lenguaje natural de GPT-4o. A través de algoritmos sofisticados y comprensión contextual, el modelo analiza contenido hablado para extraer ideas significativas. El modelo puede:
- Extraer conceptos centrales y argumentos principales del contenido hablado - Esto implica identificar las ideas fundamentales, mensajes clave y evidencia de respaldo presentada en conversaciones, presentaciones o discusiones. El modelo distingue entre puntos primarios y secundarios, asegurando que se capture la información esencial.
- Identificar puntos de decisión críticos y elementos de acción - Al analizar el flujo de la conversación y el contexto, GPT-4o reconoce momentos cuando se toman decisiones, se establecen compromisos o se asignan tareas. Esto incluye detectar tanto asignaciones explícitas ("John se encargará de esto") como implícitas ("Deberíamos investigar esto más a fondo").
- Priorizar información basada en contexto y relevancia - El modelo evalúa la importancia de diferentes piezas de información dentro de su contexto específico, considerando factores como urgencia, impacto y relación con los objetivos generales. Esto ayuda a crear resúmenes jerárquicos que enfatizan lo más importante.
- Seguir temas clave y tópicos recurrentes a través de conversaciones - GPT-4o mantiene consciencia de patrones de discusión, identificando cuando ciertos temas resurgen y cómo evolucionan con el tiempo. Esta capacidad es particularmente valiosa para el monitoreo de proyectos a largo plazo o el seguimiento de preocupaciones continuas a través de múltiples reuniones.
Ejemplo:
Este ejemplo se centra en usar GPT-4o para extraer información específica y crucial—puntos clave, decisiones, elementos de acción—del habla transcrita, yendo más allá de un resumen general.
Esto nuevamente utiliza el enfoque de dos pasos: Whisper transcribe el audio, y luego GPT-4o analiza el texto basado en un prompt diseñado para extracción.
Descarga la muestra de audio: https://files.cuantum.tech/audio/meeting_for_extraction.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:07 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-21 22:07:00 CDT" # Updated time
current_location = "Austin, Texas, United States"
print(f"Running GPT-4o key point extraction from speech example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_for_extraction.mp3' with the actual filename.
audio_file_path = "meeting_for_extraction.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before extraction.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Extract Key Points, Decisions, Actions using GPT-4o ---
def extract_key_points(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for key point extraction."""
print("\nStep 2: Extracting key points, decisions, and actions...")
if not text_to_analyze:
print("Error: No text provided for extraction.")
return None
# Prompt designed specifically for extraction
system_prompt = "You are an expert meeting analyst. Your task is to carefully read the provided transcript and extract specific types of information."
user_prompt = f"""Analyze the following meeting or discussion transcription. Identify and extract the following information, presenting each under a clear heading:
1. **Key Points / Core Concepts:** List the main topics, arguments, or fundamental ideas discussed.
2. **Decisions Made:** List any clear decisions that were reached during the discussion.
3. **Action Items:** List specific tasks assigned to individuals or the group. If possible, note who is responsible and any mentioned deadlines.
If any category has no relevant items, state "None identified".
Transcription Text:
---
{text_to_analyze}
---
Extracted Information:
"""
try:
print("Sending text to GPT-4o for extraction...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong analytical capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=600, # Adjust based on expected length of extracted info
temperature=0.2 # Lower temperature for more factual extraction
)
extracted_info = response.choices[0].message.content
print("Extraction successful.")
return extracted_info.strip()
except OpenAIError as e:
print(f"OpenAI API Error during extraction: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during extraction: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Extract Key Information
extracted_details = extract_key_points(
client,
full_transcription
)
if extracted_details:
print("\n--- Extracted Key Information ---")
print(extracted_details)
print("---------------------------------")
print("\nThis demonstrates GPT-4o identifying and structuring key takeaways from the discussion.")
else:
print("\nFailed to extract key information.")
else:
print("\nTranscription failed, cannot proceed to key point extraction.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para extraer puntos clave del contenido hablado. Después de transcribir el audio usando Whisper, GPT-4o analiza el texto para identificar y aislar información crucial como conceptos fundamentales, decisiones tomadas y elementos de acción asignados.
- Proceso de dos pasos: Al igual que la sumarización, esto se basa en:
- Paso 1 (Whisper): Transcripción del audio (
client.audio.transcriptions.create) para obtener el texto completo. La nota crítica sobre el manejo de archivos de audio mayores a 25MB mediante segmentación y concatenación sigue siendo aplicable. - Paso 2 (GPT-4o): Análisis de la transcripción completa usando
client.chat.completions.createcon un prompt específicamente diseñado para la extracción.
- Paso 1 (Whisper): Transcripción del audio (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio de una reunión o discusión donde es probable que haya información clave (meeting_for_extraction.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo la transcripción en texto plano. - Función de extracción (
extract_key_points):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de prompt para extracción: Esto es clave. El prompt instruye explícitamente a GPT-4o a actuar como analista y extraer información bajo encabezados específicos: "Puntos Clave / Conceptos Fundamentales", "Decisiones Tomadas" y "Elementos de Acción". Esta solicitud estructurada guía a GPT-4o para identificar y categorizar la información relevante con precisión. Se sugiere una
temperaturemás baja (por ejemplo, 0.2) para fomentar una salida más factual y menos creativa, adecuada para la extracción. - Utiliza
gpt-4opor sus avanzadas capacidades analíticas.
- Salida: La función devuelve una cadena de texto que contiene la información extraída, estructurada idealmente bajo los encabezados solicitados.
- Ejecución principal: El script transcribe el audio, luego pasa el texto a la función de extracción, y finalmente imprime la salida estructurada.
- Relevancia del caso de uso: Esto aborda directamente la capacidad de "Extracción de Puntos Clave". Demuestra cómo la IA puede procesar automáticamente discusiones extensas para extraer los conceptos más importantes, rastrear decisiones y listar tareas accionables, ahorrando tiempo significativo en la revisión de grabaciones o generación de seguimientos de reuniones. Destaca la capacidad de GPT-4o para comprender el flujo conversacional e identificar momentos significativos (decisiones, asignaciones) dentro del texto.
Inteligencia Emocional
Detecta el tono, el sentimiento y los matices emocionales en la comunicación hablada a través de las capacidades avanzadas de procesamiento del lenguaje natural de GPT-4o. Este sofisticado sistema realiza un análisis profundo de los patrones del habla y elementos contextuales para comprender las capas emocionales de la comunicación. El modelo puede identificar señales emocionales sutiles como:
- Inflexiones y patrones de voz que indican emoción, duda o preocupación - Incluyendo variaciones de tono, cambios en el ritmo del habla y patrones de estrés vocal que los humanos utilizan naturalmente para transmitir emociones
- Cambios en el tempo y volumen del habla que sugieren estados emocionales - Por ejemplo, un habla rápida podría indicar emoción o ansiedad, mientras que un habla más lenta podría sugerir reflexión o incertidumbre
- Marcadores emocionales contextuales como risas, suspiros o pausas - El modelo reconoce sonidos no verbales y silencios que transmiten significado emocional importante en la conversación
- Matices culturales y situacionales que afectan la expresión emocional - Comprensión de cómo diferentes culturas expresan las emociones de manera diferente y cómo el contexto influye en la interpretación emocional
Esta conciencia emocional permite a GPT-4o proporcionar respuestas más matizadas y apropiadas al contexto, haciéndolo particularmente valioso para aplicaciones en servicio al cliente (donde entender la frustración o satisfacción del cliente es crucial), conversaciones terapéuticas (donde el apoyo emocional y la comprensión son primordiales), y coaching personal (donde la motivación y el crecimiento emocional son objetivos clave). La capacidad del sistema para detectar estas señales emocionales sutiles permite una comunicación más empática y efectiva en diversos contextos profesionales y personales.
Ejemplo:
Este ejemplo explora el uso de GPT-4o para "Inteligencia Emocional" – detectando tono, sentimiento y matices emocionales en el habla.
Es importante entender cómo funciona esto con las APIs estándar actuales de OpenAI. Mientras que GPT-4o sobresale en entender la emoción desde el texto, analizar directamente características de audio como tono, variación de tono, tempo, suspiros o risas como audio no es una función principal de la transcripción estándar de Whisper o del endpoint de Chat Completions API al procesar texto transcrito.
Por lo tanto, la forma más práctica de demostrar este concepto usando estas APIs es un proceso de dos pasos:
- Transcribir Voz a Texto: Usar Whisper para obtener las palabras habladas.
- Analizar Texto para Emociones: Usar GPT-4o para analizar el texto transcrito en busca de indicadores de emoción, sentimiento o tono basados en la elección de palabras, fraseo y contexto descrito en el texto.
Descarga el audio de muestra: https://files.cuantum.tech/audio/emotional_speech.mp3
Este ejemplo de código implementa este enfoque de análisis basado en texto de dos pasos.
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:13 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-21 20:13:00 CDT" # Updated time
current_location = "Atlanta, Georgia, United States"
print(f"Running GPT-4o speech emotion analysis (text-based) example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with potentially emotional speech
# IMPORTANT: Replace 'emotional_speech.mp3' with the actual filename.
audio_file_path = "emotional_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Transcribed Text for Emotion/Sentiment using GPT-4o ---
def analyze_text_emotion(client, text_to_analyze):
"""
Sends transcribed text to GPT-4o for emotion and sentiment analysis.
Note: This analyzes the text content, not acoustic features of the original audio.
"""
print("\nStep 2: Analyzing transcribed text for emotion/sentiment...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed for text-based emotion/sentiment analysis
system_prompt = "You are an expert in communication analysis, skilled at detecting sentiment, tone, and potential underlying emotions from text."
user_prompt = f"""Analyze the following text for emotional indicators:
Text:
---
{text_to_analyze}
---
Based *only* on the words, phrasing, and punctuation in the text provided:
1. What is the overall sentiment (e.g., Positive, Negative, Neutral, Mixed)?
2. What is the likely emotional tone (e.g., Frustrated, Excited, Calm, Anxious, Sarcastic, Happy, Sad)?
3. Are there specific words or phrases that indicate these emotions? Explain briefly.
Provide the analysis:
"""
try:
print("Sending text to GPT-4o for emotion analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for nuanced understanding
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=300, # Adjust as needed
temperature=0.4 # Slightly lower temp for more grounded analysis
)
analysis = response.choices[0].message.content
print("Emotion analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\n--- Transcription Result ---")
print(transcribed_text)
print("----------------------------")
# Step 2: Analyze the transcription for emotion/sentiment
emotion_analysis = analyze_text_emotion(
client,
transcribed_text
)
if emotion_analysis:
print("\n--- Emotion/Sentiment Analysis (from Text) ---")
print(emotion_analysis)
print("----------------------------------------------")
print("\nNote: This analysis is based on the transcribed text content. It does not directly analyze acoustic features like tone of voice from the original audio.")
else:
print("\nEmotion analysis failed.")
else:
print("\nTranscription failed, cannot proceed to emotion analysis.")
# --- End of Code Example ---
Desglose del código:
- Contexto: Este código demuestra cómo GPT-4o puede utilizarse para inferir el tono emocional y el sentimiento del lenguaje hablado. Utiliza un proceso de dos pasos común para este tipo de análisis con las APIs actuales.
- Proceso de dos pasos y limitación:
- Paso 1 (Whisper): Primero, el audio se transcribe a texto utilizando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): El texto resultante es entonces analizado por GPT-4o (
client.chat.completions.create) utilizando un prompt específicamente diseñado para identificar indicadores de sentimiento y emocionales dentro del texto. - Limitación importante: La explicación (y los comentarios del código) deben establecer claramente que este método analiza el contenido lingüístico (palabras, frases) proporcionado por Whisper. No analiza directamente características acústicas del audio original como el tono, tempo, o sonidos no verbales específicos (suspiros, risas) a menos que estos sean transcritos por Whisper (lo cual no suele ocurrir con señales sutiles). La verdadera detección acústica de emociones requeriría diferentes herramientas o APIs.
- Paso 1 (Whisper): Primero, el audio se transcribe a texto utilizando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio donde las palabras del hablante puedan sugerir una emoción (emotional_speech.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo texto plano. - Función de análisis emocional (
analyze_text_emotion):- Maneja el Paso 2, tomando el texto transcrito.
- Diseño del prompt: El prompt solicita explícitamente a GPT-4o que analice el texto proporcionado para determinar el sentimiento general (Positivo/Negativo/Neutral), el probable tono emocional (Frustrado, Emocionado, etc.), y evidencia textual de respaldo. Aclara que el análisis debe basarse únicamente en el texto.
- Utiliza
gpt-4opara su sofisticada comprensión del lenguaje.
- Resultado: La función devuelve el análisis textual de GPT-4o sobre la emoción y el sentimiento inferidos.
- Ejecución principal: El script transcribe el audio, pasa el texto para su análisis, imprime ambos resultados y reitera la limitación respecto a las características acústicas.
- Relevancia de caso de uso: Aunque no analiza la acústica directamente, este enfoque basado en texto sigue siendo valioso para aplicaciones como servicio al cliente (detectando frustración/satisfacción por la elección de palabras), analizando retroalimentación, u obteniendo una sensación general del sentimiento en interacciones habladas, complementando otras formas de análisis. Demuestra la capacidad de GPT-4o para interpretar lenguaje emocional.
Recuerda usar un archivo de audio donde las palabras habladas transmitan alguna emoción para que este ejemplo sea efectivo. Reemplaza 'emotional_speech.mp3' con tu ruta de archivo.
Comprensión implícita
GPT-4o demuestra capacidades notables en la comprensión de las capas más profundas de la comunicación humana, yendo mucho más allá del simple reconocimiento de palabras para captar los matices intrincados del habla. Las sofisticadas habilidades de comprensión del modelo incluyen:
- Detectar contexto y suposiciones subyacentes
- Comprende el conocimiento implícito compartido entre hablantes
- Reconoce hechos no declarados pero comúnmente aceptados dentro de dominios específicos
- Identifica premisas ocultas en conversaciones
- Comprender referencias culturales y expresiones idiomáticas
- Procesa dichos y coloquialismos específicos de cada región
- Reconoce metáforas y analogías específicas de cada cultura
- Adapta la comprensión basándose en el contexto cultural
- Interpretar recursos retóricos
Ejemplo:
Similar a los ejemplos anteriores que involucran comprensión más profunda (Semántica, Contextual, Emocional), esto típicamente utiliza el enfoque de dos pasos: Whisper transcribe las palabras, y luego GPT-4o analiza el texto resultante, esta vez específicamente instruido para buscar capas implícitas.
Descarga el audio de muestra: https://files.cuantum.tech/audio/implicit_speech.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:21 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-12 16:21:00 CDT" # Updated time
current_location = "Dallas, Texas, United States"
print(f"Running GPT-4o implicit speech understanding example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with implicit meaning
# IMPORTANT: Replace 'implicit_speech.mp3' with the actual filename.
audio_file_path = "implicit_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Transcribed Text for Implicit Meaning using GPT-4o ---
def analyze_implicit_meaning(client, text_to_analyze):
"""
Sends transcribed text to GPT-4o to analyze implicit meanings,
assumptions, references, or rhetorical devices.
"""
print("\nStep 2: Analyzing transcribed text for implicit meaning...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed for identifying implicit communication layers
system_prompt = "You are an expert analyst of human communication, skilled at identifying meaning that is implied but not explicitly stated."
user_prompt = f"""Analyze the following statement or question:
Statement/Question:
---
{text_to_analyze}
---
Based on common knowledge, cultural context, and conversational patterns, please explain:
1. Any underlying assumptions the speaker might be making.
2. Any implicit meanings or suggestions conveyed beyond the literal words.
3. Any cultural references, idioms, or sayings being used or alluded to.
4. If it's a rhetorical question, what point is likely being made?
Provide a breakdown of the implicit layers of communication present:
"""
try:
print("Sending text to GPT-4o for implicit meaning analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for deep understanding
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=400, # Adjust as needed
temperature=0.5 # Allow for some interpretation
)
analysis = response.choices[0].message.content
print("Implicit meaning analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\n--- Transcription Result ---")
print(transcribed_text)
print("----------------------------")
# Step 2: Analyze the transcription for implicit meaning
implicit_analysis = analyze_implicit_meaning(
client,
transcribed_text
)
if implicit_analysis:
print("\n--- Implicit Meaning Analysis ---")
print(implicit_analysis)
print("-------------------------------")
print("\nThis demonstrates GPT-4o identifying meaning beyond the literal text, based on common knowledge and context.")
else:
print("\nImplicit meaning analysis failed.")
else:
print("\nTranscription failed, cannot proceed to implicit meaning analysis.")Desglose del código:
- Contexto: Este ejemplo de código demuestra la capacidad de GPT-4o para la Comprensión Implícita – captar las suposiciones no expresadas, referencias y significados integrados en el lenguaje hablado.
- Proceso en dos pasos: Sigue el patrón establecido:
- Paso 1 (Whisper): Transcribir el audio que contiene el discurso con significado implícito a texto usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): Analizar el texto transcrito usando
client.chat.completions.create, con un prompt específicamente diseñado para descubrir capas ocultas de significado.
- Paso 1 (Whisper): Transcribir el audio que contiene el discurso con significado implícito a texto usando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio donde el significado depende del conocimiento compartido, contexto cultural, o no es completamente literal (por ejemplo, usando un modismo, una pregunta retórica, o haciendo una suposición clara solo por contexto). Se usaimplicit_speech.mp3como marcador de posición. - Función de Transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo la transcripción en texto plano. - Función de Análisis Implícito (
analyze_implicit_meaning):- Maneja el Paso 2, tomando el texto transcrito.
- Ingeniería de Prompts para Significado Implícito: El prompt es clave aquí. Instruye a GPT-4o para mirar más allá de las palabras literales e identificar suposiciones subyacentes, sugerencias implícitas, referencias culturales/modismos, y el propósito detrás de preguntas retóricas.
- Utiliza
gpt-4opor su extensa base de conocimientos y capacidad de razonamiento necesaria para inferir estos elementos implícitos.
- Salida: La función devuelve el análisis textual de GPT-4o de los significados no expresados detectados en el texto de entrada.
- Ejecución Principal: El script transcribe el audio, pasa el texto para análisis implícito, e imprime tanto la transcripción literal como la interpretación de GPT-4o de los significados ocultos.
- Relevancia del Caso de Uso: Esto demuestra cómo GPT-4o puede procesar la comunicación de manera más similar a un humano, entendiendo no solo lo que se dijo, sino también lo que se quiso decir o se asumió. Esto es crucial para aplicaciones que requieren comprensión profunda, como analizar feedback de usuarios, entender diálogos con matices en reuniones, o interpretar contenido culturalmente rico.
Recuerda usar un archivo de audio que contenga habla que requiera cierto nivel de inferencia o conocimiento previo para entenderlo completamente al probar este código. Reemplaza 'implicit_speech.mp3' con tu ruta de archivo.
De la Transcripción a la Comprensión Integral
Este avance marca una transformación revolucionaria en la capacidad de la IA para procesar el habla humana. Mientras que los sistemas tradicionales como Whisper sobresalen en la transcripción - el proceso mecánico de convertir palabras habladas en texto escrito - los sistemas modernos de IA como GPT-4o logran una verdadera comprensión, entendiendo no solo las palabras en sí, sino su significado más profundo, contexto e implicaciones. Este salto adelante permite a la IA procesar la comunicación humana de manera notablemente similar a cómo los humanos entienden naturalmente la conversación, incluyendo sutiles matices, significados implícitos y relevancia contextual.
Para ilustrar esta evolución transformadora en capacidad, examinemos un ejemplo detallado que resalta el marcado contraste entre la simple transcripción y la comprensión avanzada:
- Consideremos esta declaración: "Creo que deberíamos retrasar el lanzamiento del producto hasta el próximo trimestre." Un sistema de transcripción tradicional como Whisper capturaría perfectamente estas palabras, pero ahí es donde termina su comprensión - simplemente convierte el habla a texto con alta precisión.
- GPT-4o, sin embargo, demuestra un nivel sofisticado de comprensión que refleja la comprensión humana:
- Análisis del Mensaje Principal: Más allá de solo identificar la sugerencia de reprogramación, lo entiende como una propuesta estratégica que requiere consideración cuidadosa
- Evaluación del Impacto Empresarial: Evalúa exhaustivamente cómo este retraso afectaría varios aspectos del negocio, desde la asignación de recursos hasta la programación del equipo y las implicaciones presupuestarias
- Análisis Estratégico del Mercado: Examina el contexto más amplio del mercado, incluyendo movimientos de la competencia, tendencias del mercado y potenciales ventanas de oportunidad
- Evaluación Integral de Riesgos: Evalúa las consecuencias tanto inmediatas como a largo plazo, considerando todo, desde la preparación técnica hasta el posicionamiento en el mercado
Lo que hace verdaderamente notable a GPT-4o es su capacidad para participar en discusiones analíticas matizadas sobre el contenido, abordando preguntas estratégicas complejas que requieren comprensión profunda:
- Factores Externos: ¿Qué condiciones específicas del mercado, presiones competitivas o tendencias de la industria podrían haber motivado esta sugerencia de retraso?
- Impacto en los Interesados: ¿Cómo afectaría este ajuste de cronograma las relaciones con inversores, socios y clientes? ¿Qué estrategias de comunicación podrían ser necesarias?
- Oportunidades Estratégicas: ¿Qué ventajas potenciales podrían surgir de este retraso, como desarrollo adicional de características u optimización del momento de lanzamiento al mercado?
2.3.2 ¿Qué puede hacer GPT-4o con entrada de voz?
GPT-4o representa un avance significativo en la tecnología de procesamiento de audio, ofreciendo un conjunto integral de capacidades que transforman cómo interactuamos y entendemos el contenido hablado. Como un modelo de lenguaje de vanguardia con capacidades de procesamiento multimodal, combina reconocimiento sofisticado del habla con comprensión contextual profunda para ofrecer potentes características de análisis de audio. Exploremos algunas otras funciones y capacidades de GPT-4o:
Extracción de Elementos de Acción
Ejemplo de prompt: "Enumera todas las tareas mencionadas en esta nota de voz."
GPT-4o sobresale en identificar y extraer elementos de acción del contenido hablado a través del procesamiento sofisticado del lenguaje natural. El modelo puede:
- Analizar conversaciones complejas para detectar tanto tareas explícitas ("Por favor haz X") como implícitas ("Deberíamos considerar Y")
- Distinguir entre discusiones hipotéticas y compromisos reales
- Categorizar tareas por prioridad, fecha límite y responsable
- Identificar dependencias entre diferentes elementos de acción
- Señalar requisitos de seguimiento y tareas recurrentes
Esta capacidad transforma discusiones de audio no estructuradas en listas de tareas estructuradas y accionables, mejorando significativamente la productividad de las reuniones y el seguimiento. Al mantener automáticamente un registro completo de compromisos, asegura la responsabilidad mientras reduce la carga cognitiva de los participantes que de otro modo necesitarían rastrear estos elementos manualmente. El sistema también puede integrarse con herramientas populares de gestión de tareas, haciendo que sea sencillo convertir asignaciones habladas en tickets o tareas rastreables.
Ejemplo:
Este script utiliza el proceso familiar de dos pasos: primero transcribiendo el audio con Whisper, luego analizando el texto con GPT-4o usando un prompt específicamente diseñado para identificar y estructurar elementos de acción.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/meeting_tasks.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:39 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-24 10:29:00 CDT" # Updated time
current_location = "Plano, Texas, United States"
print(f"Running GPT-4o action item extraction from speech example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_tasks.mp3' with the actual filename.
audio_file_path = "meeting_tasks.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before extraction.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Extract Action Items from Text using GPT-4o ---
def extract_action_items(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for action item extraction."""
print("\nStep 2: Extracting action items...")
if not text_to_analyze:
print("Error: No text provided for extraction.")
return None
# Prompt designed specifically for extracting structured action items
system_prompt = "You are an expert meeting analyst focused on identifying actionable tasks."
user_prompt = f"""Analyze the following meeting or discussion transcription. Identify and extract all specific action items mentioned.
For each action item, provide:
- A clear description of the task.
- The person assigned (if mentioned, otherwise state 'Unassigned' or 'Group').
- Any deadline mentioned (if mentioned, otherwise state 'No deadline mentioned').
Distinguish between definite commitments/tasks and mere suggestions or hypothetical possibilities. Only list items that sound like actual tasks or commitments.
Format the output as a numbered list.
Transcription Text:
---
{text_to_analyze}
---
Extracted Action Items:
"""
try:
print("Sending text to GPT-4o for action item extraction...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong analytical capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=500, # Adjust based on expected number of action items
temperature=0.1 # Very low temperature for factual extraction
)
extracted_actions = response.choices[0].message.content
print("Action item extraction successful.")
return extracted_actions.strip()
except OpenAIError as e:
print(f"OpenAI API Error during extraction: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during extraction: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Extract Action Items
action_items_list = extract_action_items(
client,
full_transcription
)
if action_items_list:
print("\n--- Extracted Action Items ---")
print(action_items_list)
print("------------------------------")
print("\nThis demonstrates GPT-4o identifying and structuring actionable tasks from the discussion.")
else:
print("\nFailed to extract action items.")
else:
print("\nTranscription failed, cannot proceed to action item extraction.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para extraer elementos de acción del contenido hablado. Después de transcribir el audio con Whisper, GPT-4o analiza el texto para identificar tareas específicas, asignaciones y fechas límite discutidas.
- Proceso en dos pasos: Utiliza el flujo de trabajo estándar:
- Paso 1 (Whisper): Transcribe el audio de la reunión/discusión (
client.audio.transcriptions.create) a texto. La nota sobre el manejo de archivos de audio > 25MB mediante segmentación/concatenación sigue siendo crítica para uso real. - Paso 2 (GPT-4o): Analiza la transcripción completa usando
client.chat.completions.createcon un prompt adaptado para la extracción de tareas.
- Paso 1 (Whisper): Transcribe el audio de la reunión/discusión (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio de una reunión donde se asignaron tareas (meeting_tasks.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1. - Función de extracción de elementos de acción (
extract_action_items):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de prompts para tareas: Este es el núcleo. El prompt instruye explícitamente a GPT-4o para identificar elementos de acción, distinguirlos de meras sugerencias, y extraer la descripción de la tarea, la persona asignada (si se menciona), y la fecha límite (si se menciona). Solicita un formato de lista numerada estructurada. Se recomienda una
temperaturemuy baja (por ejemplo, 0.1) para mantener la salida enfocada en la extracción factual. - Utiliza
gpt-4opor su capacidad para entender el contexto conversacional e identificar compromisos.
- Salida: La función devuelve una cadena de texto que contiene la lista estructurada de elementos de acción extraídos.
- Ejecución principal: El script transcribe el audio, pasa el texto a la función de extracción e imprime la lista resultante de tareas.
- Relevancia del caso de uso: Esto aborda directamente la capacidad de "Extracción de elementos de acción". Muestra cómo la IA puede convertir automáticamente discusiones verbales no estructuradas en listas de tareas organizadas y ejecutables. Esto aumenta significativamente la productividad al garantizar el seguimiento, clarificar responsabilidades y reducir el esfuerzo manual de rastrear compromisos hechos durante las reuniones. Destaca la capacidad de GPT-4o para analizar conversaciones complejas e identificar asignaciones de tareas tanto explícitas como implícitas.
Preguntas y respuestas sobre el audio
Ejemplo de prompt: "¿Qué dijo el orador sobre el presupuesto?"
Las capacidades avanzadas de consulta de GPT-4o permiten conversaciones naturales sobre contenido de audio, permitiendo a los usuarios hacer preguntas específicas y recibir respuestas contextualmente relevantes. El modelo puede:
- Extraer información precisa de segmentos específicos
- Comprender el contexto y las referencias a lo largo de todo el audio
- Manejar preguntas de seguimiento sobre temas previamente discutidos
- Proporcionar referencias con marca de tiempo a las partes relevantes
- Hacer referencias cruzadas de información de múltiples partes de la grabación
Esta funcionalidad transforma la forma en que interactuamos con el contenido de audio, haciéndolo tan buscable y consultable como los documentos de texto. En lugar de revisar manualmente las grabaciones, los usuarios pueden simplemente hacer preguntas en lenguaje natural y recibir respuestas precisas y concisas. El sistema es particularmente valioso para:
- Participantes de reuniones que necesitan verificar detalles específicos
- Investigadores analizando grabaciones de entrevistas
- Estudiantes revisando contenido de conferencias
- Profesionales verificando conversaciones con clientes
- Equipos que buscan entender discusiones históricas
Ejemplo:
Este script primero transcribe un archivo de audio usando Whisper y luego utiliza GPT-4o para responder una pregunta específica realizada por el usuario sobre el contenido de esa transcripción.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/meeting_for_qa.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:47 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-01-11 11:47:00 CDT" # Updated time
current_location = "Orlando, Florida, United States"
print(f"Running GPT-4o Q&A about audio example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_for_qa.mp3' with the actual filename.
audio_file_path = "meeting_for_qa.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before Q&A.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Answer Question Based on Text using GPT-4o ---
def answer_question_about_text(client, full_text, question):
"""Sends transcribed text and a question to GPT-4o to get an answer."""
print(f"\nStep 2: Answering question about the transcription...")
print(f"Question: \"{question}\"")
if not full_text:
print("Error: No transcription text provided to answer questions about.")
return None
if not question:
print("Error: No question provided.")
return None
# Prompt designed specifically for answering questions based on provided text
system_prompt = "You are an AI assistant specialized in answering questions based *only* on the provided text transcription. Do not use outside knowledge."
user_prompt = f"""Based *solely* on the following transcription text, please answer the question below. If the answer is not found in the text, state that clearly.
Transcription Text:
---
{full_text}
---
Question: {question}
Answer:
"""
try:
print("Sending transcription and question to GPT-4o...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong comprehension and answering
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=300, # Adjust based on expected answer length
temperature=0.1 # Low temperature for factual answers based on text
)
answer = response.choices[0].message.content
print("Answer generation successful.")
return answer.strip()
except OpenAIError as e:
print(f"OpenAI API Error during Q&A: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during Q&A: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
transcription = transcribe_speech(client, audio_file_path)
if transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(transcription[:1000] + "..." if len(transcription) > 1000 else transcription)
print("------------------------------------")
# --- Ask Questions about the Transcription ---
# Define the question(s) you want to ask
user_question = "What was decided about the email marketing CTA button?"
# user_question = "Who is responsible for the A/B test on Platform B?"
# user_question = "What was the engagement increase on Platform A?"
print(f"\n--- Answering Question ---")
# Step 2: Get the answer from GPT-4o
answer = answer_question_about_text(
client,
transcription,
user_question
)
if answer:
print(f"\nAnswer to '{user_question}':")
print(answer)
print("------------------------------")
print("\nThis demonstrates GPT-4o answering specific questions based on the transcribed audio content.")
else:
print(f"\nFailed to get an answer for the question: '{user_question}'")
else:
print("\nTranscription failed, cannot proceed to Q&A.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para funcionar como un sistema de preguntas y respuestas para contenido de audio. Después de transcribir el habla con Whisper, los usuarios pueden hacer preguntas específicas en lenguaje natural, y GPT-4o proporcionará respuestas basadas en la información contenida en la transcripción.
- Proceso en dos pasos: El flujo de trabajo incluye:
- Paso 1 (Whisper): Transcribir el archivo de audio relevante (o texto concatenado de fragmentos de un archivo más largo) usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): Enviar la transcripción completa junto con la pregunta específica del usuario a
client.chat.completions.create.
- Paso 1 (Whisper): Transcribir el archivo de audio relevante (o texto concatenado de fragmentos de un archivo más largo) usando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que contenga la discusión o información sobre la que el usuario podría hacer preguntas (meeting_for_qa.mp3). La nota crítica sobre el manejo de audio >25MB mediante fragmentación/concatenación antes del paso de preguntas y respuestas sigue siendo esencial. - Función de transcripción (
transcribe_speech): Maneja el Paso 1. - Función de preguntas y respuestas (
answer_question_about_text):- Maneja el Paso 2, tomando tanto la transcripción
full_textcomo laquestioncomo entrada. - Ingeniería de prompt para preguntas y respuestas: El prompt es crucial. Instruye a GPT-4o para que actúe como un asistente especializado que responde preguntas basándose únicamente en el texto de transcripción proporcionado, indicándole explícitamente que no use conocimiento externo y que indique si la respuesta no se encuentra en el texto. Este fundamento es importante para la precisión. Una
temperaturebaja (por ejemplo, 0.1) ayuda a garantizar respuestas factuales derivadas directamente del texto fuente. - Utiliza
gpt-4opor su excelente comprensión lectora y capacidades de preguntas y respuestas.
- Maneja el Paso 2, tomando tanto la transcripción
- Salida: La función devuelve la respuesta de GPT-4o a la pregunta específica realizada.
- Ejecución principal: El script transcribe el audio, define una
user_questionde ejemplo, pasa la transcripción y la pregunta a la función de preguntas y respuestas, e imprime la respuesta resultante. - Relevancia de caso de uso: Esto aborda directamente la capacidad de "Preguntas y respuestas sobre el audio". Transforma las grabaciones de audio de archivos pasivos a fuentes de conocimiento interactivas. Los usuarios pueden encontrar rápidamente detalles específicos, verificar hechos o entender partes de una discusión sin buscar manualmente en el audio, haciéndolo invaluable para revisar reuniones, conferencias, entrevistas o cualquier conversación grabada.
Recuerde usar un archivo de audio que contenga información relevante para las posibles preguntas de prueba (puede usar el audio de muestra proporcionado). Modifique la variable user_question para probar diferentes consultas contra el contenido transcrito.
Destacar momentos clave
Ejemplo de prompt: "Identifique las declaraciones más importantes realizadas en este audio."
GPT-4o sobresale en identificar y extraer momentos cruciales del contenido de audio a través de sus capacidades avanzadas de comprensión del lenguaje natural. El modelo puede:
- Identificar decisiones clave y elementos de acción
- Extraer citas y declaraciones importantes
- Resaltar discusiones estratégicas y conclusiones
- Señalar transiciones críticas en conversaciones
Esta función es particularmente valiosa para:
- Participantes de reuniones que necesitan revisar rápidamente puntos importantes
- Ejecutivos que examinan grabaciones largas en busca de puntos de decisión
- Equipos que rastrean hitos de proyectos discutidos en llamadas
- Investigadores que identifican momentos significativos en entrevistas
El modelo proporciona marcas de tiempo y resúmenes contextuales para cada momento destacado, facilitando la navegación directa a las partes más relevantes de la grabación sin revisar todo el archivo de audio.
Ejemplo:
Este script sigue el patrón establecido de dos pasos: transcribir el audio con Whisper y luego analizar el texto con GPT-4o usando un prompt diseñado para identificar declaraciones significativas, decisiones o conclusiones.
Descargue el audio de ejemplo: https://files.cuantum.tech/audio/key_discussion.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:52 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-02-14 15:52:00 CDT" # Updated time
current_location = "Tampa, Florida, United States"
print(f"Running GPT-4o key moment highlighting example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'key_discussion.mp3' with the actual filename.
audio_file_path = "key_discussion.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before highlighting.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Highlight Key Moments from Text using GPT-4o ---
def highlight_key_moments(client, text_to_analyze):
"""Sends transcribed text to GPT-4o to identify and extract key moments."""
print("\nStep 2: Identifying key moments from transcription...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed specifically for identifying key moments/statements
system_prompt = "You are an expert analyst skilled at identifying the most significant parts of a discussion or presentation."
user_prompt = f"""Analyze the following transcription text. Identify and extract the key moments, which could include:
- Important decisions made
- Critical conclusions reached
- Significant statements or impactful quotes
- Major topic shifts or transitions
- Key questions asked or answered
For each key moment identified, provide the relevant quote or a concise summary of the moment. Present the output as a list.
Transcription Text:
---
{text_to_analyze}
---
Key Moments:
"""
try:
print("Sending text to GPT-4o for key moment identification...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong comprehension
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=700, # Adjust based on expected number/length of key moments
temperature=0.3 # Lean towards factual identification
)
key_moments = response.choices[0].message.content
print("Key moment identification successful.")
return key_moments.strip()
except OpenAIError as e:
print(f"OpenAI API Error during highlighting: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during highlighting: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Highlight Key Moments
highlights = highlight_key_moments(
client,
full_transcription
)
if highlights:
print("\n--- Identified Key Moments ---")
print(highlights)
print("----------------------------")
print("\nThis demonstrates GPT-4o extracting significant parts from the discussion.")
print("\nNote: Adding precise timestamps to these moments requires further processing using Whisper's 'verbose_json' output and correlating the text.")
else:
print("\nFailed to identify key moments.")
else:
print("\nTranscription failed, cannot proceed to highlight key moments.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para Resaltar Momentos Clave del contenido hablado. Después de la transcripción mediante Whisper, GPT-4o analiza el texto para identificar y extraer las partes más significativas, como decisiones cruciales, declaraciones importantes o cambios importantes de tema.
- Proceso en dos pasos:
- Paso 1 (Whisper): Transcribir el audio (
client.audio.transcriptions.create) para obtener el texto completo. Se reitera la necesidad de segmentar/concatenar para archivos de audio > 25MB. - Paso 2 (GPT-4o): Analizar la transcripción completa usando
client.chat.completions.createcon un prompt específicamente diseñado para momentos clave.
- Paso 1 (Whisper): Transcribir el audio (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que contenga una discusión o presentación donde ocurran momentos significativos (key_discussion.mp3). - Función de Transcripción (
transcribe_speech): Maneja el Paso 1. - Función de Resaltado (
highlight_key_moments):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de Prompt para Resaltados: El prompt instruye a GPT-4o a actuar como analista e identificar varios tipos de momentos clave (decisiones, conclusiones, citas impactantes, transiciones). Solicita la cita relevante o un resumen conciso para cada momento identificado, formateado como lista.
- Utiliza
gpt-4opor su capacidad para discernir importancia y contexto dentro del texto.
- Salida: La función devuelve una cadena de texto que contiene la lista de momentos clave identificados.
- Nota sobre Marcas de Tiempo: La explicación y salida del código mencionan explícitamente que mientras este proceso identifica el texto de los momentos clave, agregar marcas de tiempo precisas requeriría pasos adicionales. Esto implica usar el formato
verbose_jsonde Whisper (que incluye marcas de tiempo por segmento) y luego correlacionar el texto identificado por GPT-4o con esos segmentos cronometrados específicos – una tarea más compleja no cubierta en este ejemplo básico. - Ejecución Principal: El script transcribe el audio, pasa el texto a la función de resaltado e imprime la lista resultante de momentos clave.
- Relevancia de Caso de Uso: Esto aborda la capacidad de "Resaltar Momentos Clave" al mostrar cómo la IA puede examinar rápidamente grabaciones potencialmente largas para destacar las partes más críticas. Esto es altamente valioso para la revisión eficiente de reuniones, entrevistas o conferencias, permitiendo a los usuarios enfocarse en lo más importante sin escuchar todo el audio.
Para propósitos de prueba, use un archivo de audio que contenga una discusión relevante con segmentos clave claros e identificables (puede usar el archivo de audio de muestra proporcionado).
2.3.3 Casos de Uso del Mundo Real
El panorama empresarial moderno depende cada vez más de la comunicación por audio en varios sectores, desde ventas y servicio al cliente hasta educación y desarrollo personal. Comprender y utilizar eficazmente estas interacciones de audio se ha vuelto crucial para las organizaciones que buscan mejorar sus operaciones, fortalecer las relaciones con los clientes e impulsar mejores resultados. Esta sección explora varias aplicaciones clave donde el procesamiento y análisis avanzado de audio puede crear un valor significativo, demostrando cómo las herramientas potenciadas por IA pueden transformar datos de audio sin procesar en información procesable.
Desde el análisis de conversaciones de ventas hasta la mejora de experiencias educativas, estos casos de uso muestran la versatilidad y el poder de las tecnologías de comprensión de audio para abordar desafíos del mundo real. Cada aplicación representa una oportunidad única para aprovechar los datos de voz para mejorar la toma de decisiones, optimizar procesos y mejorar las experiencias de usuario.
1. Potenciación de Ventas
El análisis avanzado de grabaciones de llamadas de ventas proporciona un conjunto completo de herramientas para que los equipos de ventas optimicen su rendimiento. El sistema puede identificar objeciones clave planteadas por los prospectos, permitiendo a los equipos desarrollar mejores contraargumentos y preparar respuestas por adelantado. Rastrea técnicas de cierre exitosas analizando patrones en acuerdos exitosos, revelando qué enfoques funcionan mejor para diferentes segmentos de clientes y situaciones.
El sistema también mide métricas cruciales como tasas de conversión, duración de llamadas, proporción de habla-escucha y uso de frases clave. Estos datos ayudan a los equipos de ventas a entender qué comportamientos se correlacionan con resultados exitosos. Al analizar las respuestas de los clientes y patrones de reacción, los equipos pueden refinar el momento de sus presentaciones, mejorar sus técnicas de preguntas y comprender mejor las señales de compra.
Esta tecnología también permite a los gerentes de ventas documentar y compartir enfoques efectivos en todo el equipo, creando una base de conocimientos de mejores prácticas para desafíos comunes. Este conocimiento institucional puede ser particularmente valioso para la incorporación de nuevos miembros del equipo y mantener la excelencia consistente en ventas en toda la organización.
2. Inteligencia de Reuniones
El análisis integral de reuniones transforma la manera en que las organizaciones capturan y utilizan el contenido de las reuniones. El sistema va más allá de la transcripción básica al:
- Identificar y categorizar puntos clave de discusión para fácil referencia
- Detectar y extraer automáticamente elementos de acción de las conversaciones
- Asignar responsabilidades a miembros específicos del equipo basado en compromisos verbales
- Crear líneas de tiempo estructuradas y rastrear plazos mencionados durante las reuniones
- Generar listas automatizadas de tareas con clara propiedad y fechas de vencimiento
- Resaltar puntos de decisión y resultados de reuniones
- Proporcionar archivos de reuniones con capacidad de búsqueda para referencia futura
El sistema emplea procesamiento avanzado de lenguaje natural para comprender contexto, relaciones y compromisos expresados durante las conversaciones. Esto permite la creación y asignación automática de tareas, asegurando que nada se pierda. La integración con herramientas de gestión de proyectos permite la automatización fluida del flujo de trabajo, mientras que los recordatorios inteligentes ayudan a mantener a los miembros del equipo responsables de sus compromisos.
3. Soporte al Cliente
El análisis profundo de interacciones de servicio al cliente proporciona información integral sobre la experiencia del cliente y el rendimiento del equipo de soporte. El sistema puede:
- Evaluar el sentimiento del cliente en tiempo real analizando tono, elección de palabras y flujo de conversación
- Categorizar y priorizar automáticamente problemas urgentes basado en detección de palabras clave y análisis de contexto
- Generar métricas detalladas de satisfacción a través del análisis de conversaciones y retroalimentación del cliente
- Rastrear indicadores clave de rendimiento como tiempo de primera respuesta y tiempo de resolución
- Identificar puntos de dolor comunes y problemas recurrentes a través de múltiples interacciones
- Monitorear el rendimiento del agente de soporte y la consistencia en la entrega del servicio
Esto permite a los equipos de soporte mejorar los tiempos de respuesta, identificar problemas tendencia y mantener una calidad de servicio consistente en todas las interacciones. El sistema también puede proporcionar sugerencias automáticas de entrenamiento para agentes de soporte y generar información para la mejora del producto basada en patrones de retroalimentación del cliente.
4. Diario Personal
Transforma las notas de voz en reflexiones estructuradas con análisis de contexto emocional. Utilizando procesamiento avanzado de lenguaje natural, el sistema analiza las grabaciones de voz para detectar estados emocionales, niveles de estrés y sentimiento general a través del tono de voz, elección de palabras y patrones de habla. Esto crea una entrada de diario multidimensional y rica que captura no solo lo que se dijo, sino cómo se expresó.
Las capacidades de seguimiento del estado de ánimo del sistema van más allá de simples clasificaciones positivas/negativas, identificando estados emocionales con matices como entusiasmo, incertidumbre, confianza o preocupación. Al analizar estos patrones a lo largo del tiempo, los usuarios pueden obtener información valiosa sobre su bienestar emocional e identificar desencadenantes o patrones que afectan su estado mental.
Para el seguimiento de objetivos personales, el sistema puede categorizar y etiquetar automáticamente menciones de objetivos, actualizaciones de progreso y contratiempos. Puede generar informes de progreso que muestran el impulso hacia objetivos específicos, destacar obstáculos comunes e incluso sugerir posibles soluciones basadas en estrategias exitosas anteriores. El análisis de tendencias conductuales examina patrones en la toma de decisiones, formación de hábitos y crecimiento personal, proporcionando a los usuarios información práctica para la superación personal.
5. Educación y Práctica de Idiomas
El apoyo integral al aprendizaje de idiomas revoluciona la forma en que los estudiantes practican y mejoran sus habilidades lingüísticas. El sistema proporciona varios beneficios clave:
- Análisis del Habla: Los algoritmos avanzados analizan patrones de pronunciación, detectando variaciones sutiles en fonemas, patrones de acentuación y entonación. Esto ayuda a los estudiantes a entender exactamente dónde su pronunciación difiere de los hablantes nativos.
- Detección de Errores: El sistema identifica no solo errores de pronunciación, sino también errores gramaticales, uso incorrecto de palabras y problemas sintácticos en tiempo real. Esta retroalimentación inmediata ayuda a prevenir la formación de malos hábitos.
- Retroalimentación Personalizada: En lugar de correcciones genéricas, el sistema proporciona retroalimentación contextual que considera el nivel de competencia del estudiante, su idioma nativo y patrones de interferencia comunes específicos de su origen lingüístico.
- Seguimiento del Progreso: Métricas sofisticadas rastrean varios aspectos del desarrollo del lenguaje, incluyendo rango de vocabulario, fluidez al hablar, precisión gramatical y mejora en la pronunciación a lo largo del tiempo. Los informes visuales de progreso ayudan a motivar a los estudiantes e identificar áreas que necesitan atención.
- Aprendizaje Adaptativo: Basado en el análisis de rendimiento, el sistema crea planes de ejercicios personalizados dirigidos a debilidades específicas. Estos pueden incluir ejercicios focalizados de pronunciación, ejercicios gramaticales o actividades de construcción de vocabulario adaptadas a las necesidades del estudiante.
El sistema puede rastrear la mejora a lo largo del tiempo y sugerir ejercicios específicos para las áreas que necesitan mejora, creando un entorno de aprendizaje dinámico y receptivo que se adapta al progreso de cada estudiante.
2.3.4 Consideraciones de Privacidad
La privacidad es primordial al manejar grabaciones de audio. En primer lugar, obtener el consentimiento antes de analizar grabaciones de voz de terceros es un requisito legal y ético crucial. Es esencial asegurar el permiso escrito o documentado de todos los participantes antes de procesar cualquier grabación de voz, ya sean de reuniones, entrevistas, llamadas u otro contenido de audio que involucre a terceros. Las organizaciones deben implementar un proceso formal de consentimiento que describa claramente cómo se utilizará y analizará el audio.
Se deben implementar medidas de seguridad a lo largo del flujo de trabajo de procesamiento. Después de completar el análisis, es crítico usar openai.files.delete(file_id) para eliminar los archivos de audio de los servidores de OpenAI. Esta práctica minimiza la exposición de datos y ayuda a prevenir el acceso no autorizado y posibles violaciones de datos. Las organizaciones deben establecer procedimientos automatizados de limpieza para asegurar la eliminación consistente de archivos procesados.
El almacenamiento a largo plazo de datos de voz requiere consideración especial. Nunca almacene grabaciones de voz sensibles sin la aprobación explícita de todas las partes involucradas. Las organizaciones deben implementar políticas estrictas de manejo de datos que especifiquen claramente la duración del almacenamiento, medidas de seguridad y uso previsto. Se debe tener especial cuidado con las grabaciones que contengan información personal, secretos comerciales o discusiones confidenciales. Las mejores prácticas incluyen implementar encriptación para archivos de audio almacenados y mantener registros detallados de acceso.
2.3 Comprensión del Habla en GPT-4o
En esta sección, descubrirás cómo trabajar con capacidades avanzadas de procesamiento de audio que van más allá de la transcripción básica. GPT-4o introduce un enfoque revolucionario para la comprensión del audio al permitir la integración directa de archivos de audio junto con indicaciones textuales. Esto crea un sistema de interacción multimodal fluido donde tanto las entradas de audio como de texto se procesan simultáneamente. El sistema puede analizar varios aspectos del habla, incluyendo el tono, el contexto y el significado semántico, permitiéndote construir asistentes inteligentes sofisticados que pueden escuchar, comprender y responder naturalmente dentro de cualquier contexto dado.
La tecnología representa un avance significativo en el procesamiento de audio al combinar la transcripción estilo Whisper con las capacidades avanzadas de razonamiento de GPT-4o. Mientras que Whisper sobresale en la conversión del habla a texto, GPT-4o va más allá al realizar un análisis profundo del contenido transcrito. Esta integración ocurre en una interacción fluida, eliminando la necesidad de pasos de procesamiento separados. Por ejemplo, al procesar la grabación de una reunión de negocios, GPT-4o puede simultáneamente transcribir el habla, identificar hablantes, extraer elementos de acción y generar resúmenes, todo mientras mantiene el contexto y comprende los matices sutiles en la comunicación.
Esta poderosa combinación abre posibilidades sin precedentes para crear aplicaciones de IA más intuitivas y receptivas. Estas aplicaciones no solo pueden procesar y comprender el lenguaje hablado, sino que también pueden interpretar el contexto, la emoción y la intención de formas que anteriormente no eran posibles. Ya sea analizando llamadas de servicio al cliente, procesando conferencias educativas o facilitando la comunicación multilingüe, el sistema proporciona una comprensión integral del contenido hablado que va mucho más allá de la simple transcripción.
2.3.1 ¿Por qué GPT-4o para el Habla?
Mientras que la API de Whisper sobresale en convertir el lenguaje hablado en texto escrito, GPT-4o representa un salto revolucionario en las capacidades de procesamiento de audio. Para entender la distinción, imagina a Whisper como un transcriptor altamente capacitado que puede escribir con precisión cada palabra hablada, mientras que GPT-4o funciona más como un analista experimentado con una profunda comprensión contextual.
Las capacidades de GPT-4o se extienden mucho más allá de la transcripción básica. Puede comprender y procesar el habla en múltiples niveles simultáneamente:
Comprensión Semántica
Comprende el significado real detrás de las palabras, yendo más allá de la traducción palabra por palabra. Esta capacidad avanzada permite a GPT-4o procesar el lenguaje en múltiples niveles simultáneamente, entendiendo no solo el significado literal sino también las capas semánticas más profundas, el contexto cultural y el mensaje pretendido. Esto incluye la comprensión de modismos, metáforas, referencias culturales y expresiones regionales dentro del habla, así como la detección de matices sutiles en la comunicación que podrían perderse en una simple transcripción.
Por ejemplo, cuando alguien dice "está lloviendo a cántaros", GPT-4o entiende que significa una lluvia intensa en lugar de interpretar literalmente que caen cántaros del cielo. De manera similar, al procesar frases como "mucha mierda" antes de una actuación o "pan comido" para describir una tarea fácil, el sistema interpreta correctamente estas expresiones idiomáticas dentro de su contexto cultural.
También puede captar conceptos complejos como el sarcasmo ("Oh, genial, otra reunión"), el humor ("¿Por qué cruzó el modelo GPT la calle?"), y preguntas retóricas ("¿Quién no querría eso?"), haciéndolo capaz de comprender verdaderamente la comunicación humana en todo su contexto. Esta comprensión sofisticada se extiende a referencias culturales específicas, jerga profesional e incluso variaciones dialectales regionales, asegurando una interpretación precisa independientemente del origen o estilo de comunicación del hablante.
Ejemplo:
Dado que la interacción estándar de la API de OpenAI para esto típicamente involucra primero convertir el habla a texto (usando Whisper) y después analizar ese texto para un significado más profundo (usando GPT-4o), el ejemplo de código demostrará este proceso de dos pasos.
Este script:
- Transcribirá un archivo de audio que contiene lenguaje potencialmente matizado usando Whisper.
- Enviará el texto transcrito a GPT-4o con una indicación solicitando interpretación semántica.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/idiom_speech.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:37 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-04-21 19:37:00 CDT"
current_location = "Dallas, Texas, United States"
print(f"Running GPT-4o semantic speech understanding example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with nuanced speech
# IMPORTANT: Replace 'idiom_speech.mp3' with the actual filename.
# Good examples for audio content: "Wow, that presentation just knocked my socks off!",
# "Sure, I'd LOVE to attend another three-hour meeting.", "He really spilled the beans."
audio_file_path = "idiom_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Text for Semantic Meaning using GPT-4o ---
def analyze_text_meaning(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for semantic analysis."""
print(f"\nStep 2: Analyzing text for semantic meaning: \"{text_to_analyze}\"")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Construct prompt to ask for deeper meaning
system_prompt = "You are an expert in linguistics and communication."
user_prompt = (
f"Analyze the following phrase or sentence:\n\n'{text_to_analyze}'\n\n"
"Explain its likely intended meaning, considering context, idioms, "
"metaphors, sarcasm, humor, cultural references, or other nuances. "
"Go beyond a literal, word-for-word interpretation."
)
try:
print("Sending text to GPT-4o for analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for its strong understanding capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=250, # Adjust as needed
temperature=0.5 # Lower temperature for more focused analysis
)
analysis = response.choices[0].message.content
print("Semantic analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\nTranscription Result: {transcribed_text}")
# Step 2: Analyze the transcription for meaning
semantic_analysis = analyze_text_meaning(client, transcribed_text)
if semantic_analysis:
print("\n--- Semantic Analysis Result ---")
print(semantic_analysis)
print("--------------------------------\n")
print("This demonstrates GPT-4o understanding nuances beyond literal text.")
else:
print("\nSemantic analysis failed.")
else:
print("\nTranscription failed, cannot proceed to analysis.")Desglose del código:
- Contexto: Este código demuestra la comprensión semántica avanzada del habla de GPT-4o. Va más allá de la simple transcripción al interpretar el significado, incluyendo matices como modismos, sarcasmo o frases dependientes del contexto.
- Proceso en dos pasos: El ejemplo utiliza un enfoque estándar de API en dos etapas:
- Paso 1 (Whisper): El archivo de audio se convierte primero en texto utilizando la API de Whisper (
client.audio.transcriptions.create). Esto captura las palabras habladas con precisión. - Paso 2 (GPT-4o): El texto transcrito se envía luego al modelo GPT-4o (
client.chat.completions.create) con una instrucción específica solicitando el análisis del significado detrás de las palabras, considerando interpretaciones no literales.
- Paso 1 (Whisper): El archivo de audio se convierte primero en texto utilizando la API de Whisper (
- Requisitos previos: Requiere la configuración estándar de
openaiypython-dotenv, clave API y, fundamentalmente, un archivo de audio que contenga habla con ciertos matices (por ejemplo, que incluya un modismo como "poner las cartas sobre la mesa", un comentario sarcástico como "Qué bien, otra reunión", o una frase culturalmente específica). - Función de transcripción (
transcribe_speech): Esta función maneja el Paso 1, tomando la ruta del archivo de audio y devolviendo la transcripción en texto plano de Whisper. - Función de análisis semántico (
analyze_text_meaning):- Esta función maneja el Paso 2. Recibe el texto transcrito.
- Diseño de la instrucción: Construye una instrucción específicamente pidiendo a GPT-4o que actúe como experto lingüístico y explique el significado pretendido, considerando modismos, sarcasmo, contexto, etc., solicitando explícitamente un análisis más allá de la interpretación literal.
- Utiliza
gpt-4ocomo modelo por sus sólidas capacidades de razonamiento y comprensión. - Devuelve el análisis proporcionado por GPT-4o.
- Ejecución principal: El script primero transcribe el audio. Si tiene éxito, pasa el texto a la función de análisis. Finalmente, imprime tanto la transcripción literal como la interpretación semántica de GPT-4o.
- Relevancia del caso de uso: Este ejemplo muestra claramente cómo la combinación de Whisper y GPT-4o permite una comprensión más profunda del lenguaje hablado que la simple transcripción. Demuestra la capacidad descrita – comprender modismos ("llover a cántaros"), sarcasmo, humor y contexto – haciendo que la interacción con la IA esté más alineada con la comunicación humana.
Recuerda usar un archivo de audio que contenga lenguaje no literal para las pruebas para mostrar mejor el paso de análisis semántico. Reemplaza 'idiom_speech.mp3' con tu ruta de archivo real.
Análisis Contextual
Interpreta las declaraciones dentro de su contexto más amplio, teniendo en cuenta la información circundante, discusiones previas, referencias culturales y factores situacionales. Esto incluye entender cómo el tiempo, lugar, relaciones entre hablantes y conversaciones previas influyen en el significado. El análisis considera múltiples capas de contexto:
- Contexto temporal: Cuándo se dice algo (hora del día, día de la semana, temporada o período histórico)
- Contexto social: Las relaciones entre hablantes, dinámicas de poder y normas sociales
- Contexto físico: La ubicación y el entorno donde ocurre la comunicación
- Contexto cultural: Conocimientos, creencias y costumbres compartidas que influyen en la interpretación
Por ejemplo, la frase "se está haciendo tarde" podría significar diferentes cosas en diferentes contextos:
- Durante una reunión de trabajo: Una sugerencia cortés para concluir la discusión
- En una reunión social: Una indicación de que alguien necesita irse
- De un padre a un hijo: Un recordatorio sobre la hora de dormir
- En una discusión de proyecto: Preocupación por plazos que se aproximan
GPT-4o analiza estas pistas contextuales junto con factores adicionales como el tono de voz, patrones de habla e historial de conversación para proporcionar interpretaciones más precisas y matizadas de la comunicación hablada. Esta comprensión contextual profunda permite al sistema captar el verdadero significado pretendido detrás de las palabras, más allá de su interpretación literal.
Ejemplo:
Este caso de uso se centra en la capacidad de GPT-4o para interpretar el habla transcrita dentro de su contexto más amplio (temporal, social, físico, cultural). Como en el ejemplo de comprensión semántica, esto típicamente involucra un proceso de dos pasos: transcribir el habla con Whisper, luego analizar el texto con GPT-4o, pero esta vez proporcionando explícitamente información contextual a GPT-4o.
Este ejemplo de código:
- Transcribirá una frase simple dependiente del contexto desde un archivo de audio usando Whisper.
- Enviará el texto transcrito a GPT-4o múltiples veces, cada vez proporcionando un contexto diferente.
- Mostrará cómo la interpretación de GPT-4o de la misma frase cambia según el contexto proporcionado.
Descarga el audio de ejemplo: https://files.cuantum.tech/audio/context_phrase.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:44 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-02-11 11:44:00 CDT" # Updated time
current_location = "Miami, Florida, United States"
print(f"Running GPT-4o contextual speech analysis example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with the context-dependent phrase
# IMPORTANT: Replace 'context_phrase.mp3' with the actual filename.
# The audio content should ideally be just "It's getting late."
audio_file_path = "context_phrase.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from the previous example (gpt4o_speech_semantic_py)
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Text for Meaning WITHIN a Given Context using GPT-4o ---
def analyze_text_with_context(client, text_to_analyze, context_description):
"""Sends transcribed text and context description to GPT-4o for analysis."""
print(f"\nStep 2: Analyzing text \"{text_to_analyze}\" within context...")
print(f"Context Provided: {context_description}")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
if not context_description:
print("Error: Context description must be provided for this analysis.")
return None
# Construct prompt asking for interpretation based on context
system_prompt = "You are an expert in analyzing communication and understanding context."
user_prompt = (
f"Consider the phrase: '{text_to_analyze}'\n\n"
f"Now, consider the specific context in which it was said: '{context_description}'\n\n"
"Based *only* on this context, explain the likely intended meaning, implication, "
"or function of the phrase in this situation."
)
try:
print("Sending text and context to GPT-4o for analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong contextual reasoning
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=200, # Adjust as needed
temperature=0.3 # Lower temperature for more focused contextual interpretation
)
analysis = response.choices[0].message.content
print("Contextual analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio phrase
transcribed_phrase = transcribe_speech(client, audio_file_path)
if transcribed_phrase:
print(f"\nTranscription Result: \"{transcribed_phrase}\"")
# Define different contexts for the same phrase
contexts = [
"Said during a business meeting scheduled to end at 5:00 PM, spoken at 4:55 PM.",
"Said by a guest at a social party around 1:00 AM.",
"Said by a parent to a young child at 9:00 PM on a school night.",
"Said during a critical project discussion about an upcoming deadline, spoken late in the evening.",
"Said by someone looking out the window on a short winter afternoon."
]
print("\n--- Analyzing Phrase in Different Contexts ---")
# Step 2: Analyze the phrase within each context
for i, context in enumerate(contexts):
print(f"\n--- Analysis for Context {i+1} ---")
contextual_meaning = analyze_text_with_context(
client,
transcribed_phrase,
context
)
if contextual_meaning:
print(f"Meaning in Context: {contextual_meaning}")
else:
print("Contextual analysis failed for this context.")
print("------------------------------------")
print("\nThis demonstrates how GPT-4o interprets the same phrase differently based on provided context.")
else:
print("\nTranscription failed, cannot proceed to contextual analysis.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para el análisis contextual del habla. Muestra cómo la interpretación de una frase hablada puede cambiar drásticamente según la situación circundante (factores temporales, sociales y situacionales).
- Proceso de dos pasos con inyección de contexto:
- Paso 1 (Whisper): El archivo de audio que contiene una frase dependiente del contexto (por ejemplo, "Se está haciendo tarde") se transcribe a texto usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): El texto transcrito se envía entonces a GPT-4o (
client.chat.completions.create), pero de manera crucial, el prompt ahora incluye una descripción del contexto específico en el que se pronunció la frase.
- Paso 1 (Whisper): El archivo de audio que contiene una frase dependiente del contexto (por ejemplo, "Se está haciendo tarde") se transcribe a texto usando
- Requisitos previos: Requiere la configuración estándar de
openaiypython-dotenv, clave API, y un archivo de audio que contenga una frase simple cuyo significado dependa en gran medida del contexto (el ejemplo usa "Se está haciendo tarde"). - Función de transcripción (
transcribe_speech): Esta función (reutilizada del ejemplo anterior) maneja el Paso 1. - Función de análisis contextual (
analyze_text_with_context):- Esta función maneja el Paso 2 y ahora acepta un argumento adicional:
context_description. - Diseño del prompt: El prompt proporciona explícitamente tanto la frase transcrita como la
context_descriptiona GPT-4o, pidiéndole que interprete la frase dentro de esa situación específica. - Utiliza
gpt-4opor su capacidad de razonar basándose en el contexto proporcionado.
- Esta función maneja el Paso 2 y ahora acepta un argumento adicional:
- Demostración de la dependencia del contexto (Ejecución principal):
- El script primero transcribe la frase (por ejemplo, "Se está haciendo tarde").
- Luego define una lista de diferentes descripciones de contexto (finalización de reunión, fiesta nocturna, hora de dormir, fecha límite de proyecto, día corto de invierno).
- Llama a la función
analyze_text_with_contextrepetidamente, usando la misma frase transcrita pero proporcionando una descripción de contexto diferente cada vez. - Al imprimir el resultado del análisis para cada contexto, el script muestra claramente cómo la interpretación de GPT-4o cambia según el contexto proporcionado (por ejemplo, sugiriendo concluir vs. indicando cansancio vs. notando la disminución de la luz del día).
- Relevancia del caso de uso: Esto destaca la comprensión sofisticada de GPT-4o, yendo más allá de las palabras literales para captar el significado pretendido influenciado por factores temporales, sociales y situacionales. Esto es vital para aplicaciones que necesitan una interpretación precisa de la comunicación en el mundo real en negocios, interacciones sociales o cualquier entorno rico en contexto. Muestra cómo los desarrolladores pueden proporcionar contexto relevante junto con el texto transcrito para obtener interpretaciones más precisas y matizadas de la IA.
Para probar este código efectivamente, crea un archivo de audio que contenga solo la frase "Se está haciendo tarde" (u otra frase dependiente del contexto), o descarga el archivo de muestra proporcionado. Recuerda actualizar la ruta 'context_phrase.mp3' para que coincida con la ubicación de tu archivo.
Generación de resúmenes
Las capacidades de generación de resúmenes de GPT-4o representan un avance significativo en el análisis de contenido impulsado por IA. El sistema crea resúmenes concisos y significativos de discusiones complejas mediante la destilación inteligente de información clave de conversaciones, reuniones o presentaciones extensas. Utilizando procesamiento avanzado del lenguaje natural y comprensión contextual, GPT-4o puede identificar temas principales, puntos críticos y conclusiones esenciales mientras mantiene el significado central y el contexto de la discusión original.
El sistema emplea varias técnicas sofisticadas:
- Reconocimiento de patrones: Identifica temas recurrentes y puntos importantes de discusión a lo largo de conversaciones extensas
- Análisis contextual: Comprende el contexto más amplio y las relaciones entre diferentes partes de la discusión
- Detección de prioridades: Determina automáticamente qué información es más crucial para el resumen
- Comprensión semántica: Capta significados subyacentes e implicaciones más allá del contenido superficial
Los resúmenes generados pueden personalizarse para diferentes propósitos y audiencias:
- Informes ejecutivos: Enfocados en perspectivas estratégicas y decisiones de alto nivel
- Actas de reuniones: Documentación detallada de discusiones y elementos de acción
- Resúmenes rápidos: Aspectos destacados condensados para consumo rápido de información
- Resúmenes técnicos: Énfasis en detalles técnicos específicos y especificaciones
Lo que distingue a GPT-4o es su capacidad para preservar detalles importantes mientras reduce significativamente la sobrecarga de información, convirtiéndolo en una herramienta invaluable para la comunicación empresarial moderna y la gestión del conocimiento.
Ejemplo:
Este ejemplo se centra en la capacidad de GPT-4o para generar resúmenes concisos y significativos de contenido hablado potencialmente extenso obtenido a través de Whisper.
Esto involucra el proceso familiar de dos pasos: primero, transcribir el audio con Whisper para obtener el texto completo, y segundo, usar las capacidades de comprensión del lenguaje de GPT-4o para analizar y resumir ese texto según necesidades específicas. Este ejemplo demostrará la generación de diferentes tipos de resúmenes a partir de la misma transcripción.
Descarga el audio de muestra: https://files.cuantum.tech/audio/discussion_audio.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:59 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-04-10 15:59:00 CDT" # Updated time
current_location = "Houston, Texas, United States"
print(f"Running GPT-4o speech summarization example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'discussion_audio.mp3' with the actual filename.
audio_file_path = "discussion_audio.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before summarization.")
except OSError:
pass # Ignore size check error, proceed with transcription attempt
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Generate Summary from Text using GPT-4o ---
def summarize_text(client, text_to_summarize, summary_style="concise overview"):
"""Sends transcribed text to GPT-4o for summarization."""
print(f"\nStep 2: Generating '{summary_style}' summary...")
if not text_to_summarize:
print("Error: No text provided for summarization.")
return None
# Tailor the prompt based on the desired summary style
system_prompt = "You are an expert meeting summarizer and information distiller."
user_prompt = f"""Please generate a {summary_style} of the following discussion transcription.
Focus on accurately capturing the key information relevant to a {summary_style}. For example:
- For an 'executive briefing', focus on strategic points, decisions, and outcomes.
- For 'detailed meeting minutes', include main topics, key arguments, decisions, and action items.
- For a 'concise overview', provide the absolute main points and purpose.
- For a 'technical summary', emphasize technical details, specifications, or findings.
Transcription Text:
---
{text_to_summarize}
---
Generate the {summary_style}:
"""
try:
print(f"Sending text to GPT-4o for {summary_style}...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong summarization
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=400, # Adjust based on expected summary length
temperature=0.5 # Balance creativity and focus
)
summary = response.choices[0].message.content
print(f"'{summary_style}' generation successful.")
return summary.strip()
except OpenAIError as e:
print(f"OpenAI API Error during summarization: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during summarization: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("--------------------------")
# Step 2: Generate summaries in different styles
summary_styles_to_generate = [
"concise overview",
"detailed meeting minutes with action items",
"executive briefing focusing on decisions",
# "technical summary" # Add if relevant to your audio content
]
print("\n--- Generating Summaries ---")
for style in summary_styles_to_generate:
print(f"\n--- Summary Style: {style} ---")
summary_result = summarize_text(
client,
full_transcription,
summary_style=style
)
if summary_result:
print(summary_result)
else:
print(f"Failed to generate '{style}'.")
print("------------------------------------")
print("\nThis demonstrates GPT-4o generating different summaries from the same transcription based on the prompt.")
else:
print("\nTranscription failed, cannot proceed to summarization.")Desglose del código:
- Contexto: Este código demuestra la capacidad avanzada de GPT-4o para generar resúmenes de contenido hablado. Utiliza un proceso de dos pasos: transcribir el audio con Whisper y luego usar GPT-4o para destilar inteligentemente la información clave de la transcripción en un resumen conciso.
- Manejo de Audio Extenso (Nota Crucial): Los prerrequisitos y comentarios del código abordan explícitamente el límite de 25MB de la API de Whisper. Para reuniones o presentaciones largas del mundo real, el audio debe ser dividido en fragmentos, cada fragmento transcrito por separado, y los textos resultantes concatenados antes de ser enviados al paso de resumen. El ejemplo de código procesa un solo archivo de audio por simplicidad, pero destaca este flujo de trabajo esencial para contenido más largo.
- Prerrequisitos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que representa la discusión a resumir (discussion_audio.mp3). - Función de Transcripción (
transcribe_speech): Maneja el Paso 1, convirtiendo el audio de entrada (o fragmento de audio) en texto plano usando Whisper. - Función de Resumen (
summarize_text):- Maneja el Paso 2, tomando el texto transcrito completo como entrada.
- Resúmenes Personalizables: Acepta un argumento
summary_style(por ejemplo, "informe ejecutivo", "actas detalladas de reunión"). - Ingeniería de Prompt: El prompt enviado a GPT-4o se construye dinámicamente según el
summary_stylesolicitado. Instruye a GPT-4o para actuar como un experto en resúmenes y adaptar la salida (enfocándose en puntos estratégicos, elementos de acción, detalles técnicos, etc.) según el estilo deseado. - Utiliza
gpt-4opor sus avanzadas capacidades de comprensión y resumen.
- Demostración de Diferentes Tipos de Resumen (Ejecución Principal):
- El script primero obtiene la transcripción completa.
- Luego define una lista de diferentes
summary_styles_to_generate. - Llama a la función
summarize_textmúltiples veces, pasando la misma transcripción completa cada vez pero variando el argumentosummary_style. - Al imprimir cada resumen resultante, el script muestra claramente cómo GPT-4o adapta el nivel de detalle y enfoque según el prompt, generando salidas distintas (por ejemplo, una visión general breve vs. actas detalladas) del mismo texto fuente.
- Relevancia de Caso de Uso: Esto aborda directamente la capacidad de "Generación de Resúmenes". Muestra cómo la combinación de Whisper y GPT-4o puede transformar discusiones habladas extensas en varios formatos útiles (informes ejecutivos, actas de reuniones, resúmenes rápidos), ahorrando tiempo y mejorando la gestión del conocimiento en negocios, educación y creación de contenido.
Extracción de Puntos Clave
Identifica y destaca información crucial aprovechando las capacidades avanzadas de procesamiento del lenguaje natural de GPT-4o. A través de algoritmos sofisticados y comprensión contextual, el modelo analiza contenido hablado para extraer ideas significativas. El modelo puede:
- Extraer conceptos centrales y argumentos principales del contenido hablado - Esto implica identificar las ideas fundamentales, mensajes clave y evidencia de respaldo presentada en conversaciones, presentaciones o discusiones. El modelo distingue entre puntos primarios y secundarios, asegurando que se capture la información esencial.
- Identificar puntos de decisión críticos y elementos de acción - Al analizar el flujo de la conversación y el contexto, GPT-4o reconoce momentos cuando se toman decisiones, se establecen compromisos o se asignan tareas. Esto incluye detectar tanto asignaciones explícitas ("John se encargará de esto") como implícitas ("Deberíamos investigar esto más a fondo").
- Priorizar información basada en contexto y relevancia - El modelo evalúa la importancia de diferentes piezas de información dentro de su contexto específico, considerando factores como urgencia, impacto y relación con los objetivos generales. Esto ayuda a crear resúmenes jerárquicos que enfatizan lo más importante.
- Seguir temas clave y tópicos recurrentes a través de conversaciones - GPT-4o mantiene consciencia de patrones de discusión, identificando cuando ciertos temas resurgen y cómo evolucionan con el tiempo. Esta capacidad es particularmente valiosa para el monitoreo de proyectos a largo plazo o el seguimiento de preocupaciones continuas a través de múltiples reuniones.
Ejemplo:
Este ejemplo se centra en usar GPT-4o para extraer información específica y crucial—puntos clave, decisiones, elementos de acción—del habla transcrita, yendo más allá de un resumen general.
Esto nuevamente utiliza el enfoque de dos pasos: Whisper transcribe el audio, y luego GPT-4o analiza el texto basado en un prompt diseñado para extracción.
Descarga la muestra de audio: https://files.cuantum.tech/audio/meeting_for_extraction.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:07 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-21 22:07:00 CDT" # Updated time
current_location = "Austin, Texas, United States"
print(f"Running GPT-4o key point extraction from speech example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_for_extraction.mp3' with the actual filename.
audio_file_path = "meeting_for_extraction.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before extraction.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Extract Key Points, Decisions, Actions using GPT-4o ---
def extract_key_points(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for key point extraction."""
print("\nStep 2: Extracting key points, decisions, and actions...")
if not text_to_analyze:
print("Error: No text provided for extraction.")
return None
# Prompt designed specifically for extraction
system_prompt = "You are an expert meeting analyst. Your task is to carefully read the provided transcript and extract specific types of information."
user_prompt = f"""Analyze the following meeting or discussion transcription. Identify and extract the following information, presenting each under a clear heading:
1. **Key Points / Core Concepts:** List the main topics, arguments, or fundamental ideas discussed.
2. **Decisions Made:** List any clear decisions that were reached during the discussion.
3. **Action Items:** List specific tasks assigned to individuals or the group. If possible, note who is responsible and any mentioned deadlines.
If any category has no relevant items, state "None identified".
Transcription Text:
---
{text_to_analyze}
---
Extracted Information:
"""
try:
print("Sending text to GPT-4o for extraction...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong analytical capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=600, # Adjust based on expected length of extracted info
temperature=0.2 # Lower temperature for more factual extraction
)
extracted_info = response.choices[0].message.content
print("Extraction successful.")
return extracted_info.strip()
except OpenAIError as e:
print(f"OpenAI API Error during extraction: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during extraction: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Extract Key Information
extracted_details = extract_key_points(
client,
full_transcription
)
if extracted_details:
print("\n--- Extracted Key Information ---")
print(extracted_details)
print("---------------------------------")
print("\nThis demonstrates GPT-4o identifying and structuring key takeaways from the discussion.")
else:
print("\nFailed to extract key information.")
else:
print("\nTranscription failed, cannot proceed to key point extraction.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para extraer puntos clave del contenido hablado. Después de transcribir el audio usando Whisper, GPT-4o analiza el texto para identificar y aislar información crucial como conceptos fundamentales, decisiones tomadas y elementos de acción asignados.
- Proceso de dos pasos: Al igual que la sumarización, esto se basa en:
- Paso 1 (Whisper): Transcripción del audio (
client.audio.transcriptions.create) para obtener el texto completo. La nota crítica sobre el manejo de archivos de audio mayores a 25MB mediante segmentación y concatenación sigue siendo aplicable. - Paso 2 (GPT-4o): Análisis de la transcripción completa usando
client.chat.completions.createcon un prompt específicamente diseñado para la extracción.
- Paso 1 (Whisper): Transcripción del audio (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio de una reunión o discusión donde es probable que haya información clave (meeting_for_extraction.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo la transcripción en texto plano. - Función de extracción (
extract_key_points):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de prompt para extracción: Esto es clave. El prompt instruye explícitamente a GPT-4o a actuar como analista y extraer información bajo encabezados específicos: "Puntos Clave / Conceptos Fundamentales", "Decisiones Tomadas" y "Elementos de Acción". Esta solicitud estructurada guía a GPT-4o para identificar y categorizar la información relevante con precisión. Se sugiere una
temperaturemás baja (por ejemplo, 0.2) para fomentar una salida más factual y menos creativa, adecuada para la extracción. - Utiliza
gpt-4opor sus avanzadas capacidades analíticas.
- Salida: La función devuelve una cadena de texto que contiene la información extraída, estructurada idealmente bajo los encabezados solicitados.
- Ejecución principal: El script transcribe el audio, luego pasa el texto a la función de extracción, y finalmente imprime la salida estructurada.
- Relevancia del caso de uso: Esto aborda directamente la capacidad de "Extracción de Puntos Clave". Demuestra cómo la IA puede procesar automáticamente discusiones extensas para extraer los conceptos más importantes, rastrear decisiones y listar tareas accionables, ahorrando tiempo significativo en la revisión de grabaciones o generación de seguimientos de reuniones. Destaca la capacidad de GPT-4o para comprender el flujo conversacional e identificar momentos significativos (decisiones, asignaciones) dentro del texto.
Inteligencia Emocional
Detecta el tono, el sentimiento y los matices emocionales en la comunicación hablada a través de las capacidades avanzadas de procesamiento del lenguaje natural de GPT-4o. Este sofisticado sistema realiza un análisis profundo de los patrones del habla y elementos contextuales para comprender las capas emocionales de la comunicación. El modelo puede identificar señales emocionales sutiles como:
- Inflexiones y patrones de voz que indican emoción, duda o preocupación - Incluyendo variaciones de tono, cambios en el ritmo del habla y patrones de estrés vocal que los humanos utilizan naturalmente para transmitir emociones
- Cambios en el tempo y volumen del habla que sugieren estados emocionales - Por ejemplo, un habla rápida podría indicar emoción o ansiedad, mientras que un habla más lenta podría sugerir reflexión o incertidumbre
- Marcadores emocionales contextuales como risas, suspiros o pausas - El modelo reconoce sonidos no verbales y silencios que transmiten significado emocional importante en la conversación
- Matices culturales y situacionales que afectan la expresión emocional - Comprensión de cómo diferentes culturas expresan las emociones de manera diferente y cómo el contexto influye en la interpretación emocional
Esta conciencia emocional permite a GPT-4o proporcionar respuestas más matizadas y apropiadas al contexto, haciéndolo particularmente valioso para aplicaciones en servicio al cliente (donde entender la frustración o satisfacción del cliente es crucial), conversaciones terapéuticas (donde el apoyo emocional y la comprensión son primordiales), y coaching personal (donde la motivación y el crecimiento emocional son objetivos clave). La capacidad del sistema para detectar estas señales emocionales sutiles permite una comunicación más empática y efectiva en diversos contextos profesionales y personales.
Ejemplo:
Este ejemplo explora el uso de GPT-4o para "Inteligencia Emocional" – detectando tono, sentimiento y matices emocionales en el habla.
Es importante entender cómo funciona esto con las APIs estándar actuales de OpenAI. Mientras que GPT-4o sobresale en entender la emoción desde el texto, analizar directamente características de audio como tono, variación de tono, tempo, suspiros o risas como audio no es una función principal de la transcripción estándar de Whisper o del endpoint de Chat Completions API al procesar texto transcrito.
Por lo tanto, la forma más práctica de demostrar este concepto usando estas APIs es un proceso de dos pasos:
- Transcribir Voz a Texto: Usar Whisper para obtener las palabras habladas.
- Analizar Texto para Emociones: Usar GPT-4o para analizar el texto transcrito en busca de indicadores de emoción, sentimiento o tono basados en la elección de palabras, fraseo y contexto descrito en el texto.
Descarga el audio de muestra: https://files.cuantum.tech/audio/emotional_speech.mp3
Este ejemplo de código implementa este enfoque de análisis basado en texto de dos pasos.
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:13 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-21 20:13:00 CDT" # Updated time
current_location = "Atlanta, Georgia, United States"
print(f"Running GPT-4o speech emotion analysis (text-based) example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with potentially emotional speech
# IMPORTANT: Replace 'emotional_speech.mp3' with the actual filename.
audio_file_path = "emotional_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Transcribed Text for Emotion/Sentiment using GPT-4o ---
def analyze_text_emotion(client, text_to_analyze):
"""
Sends transcribed text to GPT-4o for emotion and sentiment analysis.
Note: This analyzes the text content, not acoustic features of the original audio.
"""
print("\nStep 2: Analyzing transcribed text for emotion/sentiment...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed for text-based emotion/sentiment analysis
system_prompt = "You are an expert in communication analysis, skilled at detecting sentiment, tone, and potential underlying emotions from text."
user_prompt = f"""Analyze the following text for emotional indicators:
Text:
---
{text_to_analyze}
---
Based *only* on the words, phrasing, and punctuation in the text provided:
1. What is the overall sentiment (e.g., Positive, Negative, Neutral, Mixed)?
2. What is the likely emotional tone (e.g., Frustrated, Excited, Calm, Anxious, Sarcastic, Happy, Sad)?
3. Are there specific words or phrases that indicate these emotions? Explain briefly.
Provide the analysis:
"""
try:
print("Sending text to GPT-4o for emotion analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for nuanced understanding
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=300, # Adjust as needed
temperature=0.4 # Slightly lower temp for more grounded analysis
)
analysis = response.choices[0].message.content
print("Emotion analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\n--- Transcription Result ---")
print(transcribed_text)
print("----------------------------")
# Step 2: Analyze the transcription for emotion/sentiment
emotion_analysis = analyze_text_emotion(
client,
transcribed_text
)
if emotion_analysis:
print("\n--- Emotion/Sentiment Analysis (from Text) ---")
print(emotion_analysis)
print("----------------------------------------------")
print("\nNote: This analysis is based on the transcribed text content. It does not directly analyze acoustic features like tone of voice from the original audio.")
else:
print("\nEmotion analysis failed.")
else:
print("\nTranscription failed, cannot proceed to emotion analysis.")
# --- End of Code Example ---
Desglose del código:
- Contexto: Este código demuestra cómo GPT-4o puede utilizarse para inferir el tono emocional y el sentimiento del lenguaje hablado. Utiliza un proceso de dos pasos común para este tipo de análisis con las APIs actuales.
- Proceso de dos pasos y limitación:
- Paso 1 (Whisper): Primero, el audio se transcribe a texto utilizando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): El texto resultante es entonces analizado por GPT-4o (
client.chat.completions.create) utilizando un prompt específicamente diseñado para identificar indicadores de sentimiento y emocionales dentro del texto. - Limitación importante: La explicación (y los comentarios del código) deben establecer claramente que este método analiza el contenido lingüístico (palabras, frases) proporcionado por Whisper. No analiza directamente características acústicas del audio original como el tono, tempo, o sonidos no verbales específicos (suspiros, risas) a menos que estos sean transcritos por Whisper (lo cual no suele ocurrir con señales sutiles). La verdadera detección acústica de emociones requeriría diferentes herramientas o APIs.
- Paso 1 (Whisper): Primero, el audio se transcribe a texto utilizando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio donde las palabras del hablante puedan sugerir una emoción (emotional_speech.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo texto plano. - Función de análisis emocional (
analyze_text_emotion):- Maneja el Paso 2, tomando el texto transcrito.
- Diseño del prompt: El prompt solicita explícitamente a GPT-4o que analice el texto proporcionado para determinar el sentimiento general (Positivo/Negativo/Neutral), el probable tono emocional (Frustrado, Emocionado, etc.), y evidencia textual de respaldo. Aclara que el análisis debe basarse únicamente en el texto.
- Utiliza
gpt-4opara su sofisticada comprensión del lenguaje.
- Resultado: La función devuelve el análisis textual de GPT-4o sobre la emoción y el sentimiento inferidos.
- Ejecución principal: El script transcribe el audio, pasa el texto para su análisis, imprime ambos resultados y reitera la limitación respecto a las características acústicas.
- Relevancia de caso de uso: Aunque no analiza la acústica directamente, este enfoque basado en texto sigue siendo valioso para aplicaciones como servicio al cliente (detectando frustración/satisfacción por la elección de palabras), analizando retroalimentación, u obteniendo una sensación general del sentimiento en interacciones habladas, complementando otras formas de análisis. Demuestra la capacidad de GPT-4o para interpretar lenguaje emocional.
Recuerda usar un archivo de audio donde las palabras habladas transmitan alguna emoción para que este ejemplo sea efectivo. Reemplaza 'emotional_speech.mp3' con tu ruta de archivo.
Comprensión implícita
GPT-4o demuestra capacidades notables en la comprensión de las capas más profundas de la comunicación humana, yendo mucho más allá del simple reconocimiento de palabras para captar los matices intrincados del habla. Las sofisticadas habilidades de comprensión del modelo incluyen:
- Detectar contexto y suposiciones subyacentes
- Comprende el conocimiento implícito compartido entre hablantes
- Reconoce hechos no declarados pero comúnmente aceptados dentro de dominios específicos
- Identifica premisas ocultas en conversaciones
- Comprender referencias culturales y expresiones idiomáticas
- Procesa dichos y coloquialismos específicos de cada región
- Reconoce metáforas y analogías específicas de cada cultura
- Adapta la comprensión basándose en el contexto cultural
- Interpretar recursos retóricos
Ejemplo:
Similar a los ejemplos anteriores que involucran comprensión más profunda (Semántica, Contextual, Emocional), esto típicamente utiliza el enfoque de dos pasos: Whisper transcribe las palabras, y luego GPT-4o analiza el texto resultante, esta vez específicamente instruido para buscar capas implícitas.
Descarga el audio de muestra: https://files.cuantum.tech/audio/implicit_speech.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:21 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-12 16:21:00 CDT" # Updated time
current_location = "Dallas, Texas, United States"
print(f"Running GPT-4o implicit speech understanding example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with implicit meaning
# IMPORTANT: Replace 'implicit_speech.mp3' with the actual filename.
audio_file_path = "implicit_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Transcribed Text for Implicit Meaning using GPT-4o ---
def analyze_implicit_meaning(client, text_to_analyze):
"""
Sends transcribed text to GPT-4o to analyze implicit meanings,
assumptions, references, or rhetorical devices.
"""
print("\nStep 2: Analyzing transcribed text for implicit meaning...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed for identifying implicit communication layers
system_prompt = "You are an expert analyst of human communication, skilled at identifying meaning that is implied but not explicitly stated."
user_prompt = f"""Analyze the following statement or question:
Statement/Question:
---
{text_to_analyze}
---
Based on common knowledge, cultural context, and conversational patterns, please explain:
1. Any underlying assumptions the speaker might be making.
2. Any implicit meanings or suggestions conveyed beyond the literal words.
3. Any cultural references, idioms, or sayings being used or alluded to.
4. If it's a rhetorical question, what point is likely being made?
Provide a breakdown of the implicit layers of communication present:
"""
try:
print("Sending text to GPT-4o for implicit meaning analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for deep understanding
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=400, # Adjust as needed
temperature=0.5 # Allow for some interpretation
)
analysis = response.choices[0].message.content
print("Implicit meaning analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\n--- Transcription Result ---")
print(transcribed_text)
print("----------------------------")
# Step 2: Analyze the transcription for implicit meaning
implicit_analysis = analyze_implicit_meaning(
client,
transcribed_text
)
if implicit_analysis:
print("\n--- Implicit Meaning Analysis ---")
print(implicit_analysis)
print("-------------------------------")
print("\nThis demonstrates GPT-4o identifying meaning beyond the literal text, based on common knowledge and context.")
else:
print("\nImplicit meaning analysis failed.")
else:
print("\nTranscription failed, cannot proceed to implicit meaning analysis.")Desglose del código:
- Contexto: Este ejemplo de código demuestra la capacidad de GPT-4o para la Comprensión Implícita – captar las suposiciones no expresadas, referencias y significados integrados en el lenguaje hablado.
- Proceso en dos pasos: Sigue el patrón establecido:
- Paso 1 (Whisper): Transcribir el audio que contiene el discurso con significado implícito a texto usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): Analizar el texto transcrito usando
client.chat.completions.create, con un prompt específicamente diseñado para descubrir capas ocultas de significado.
- Paso 1 (Whisper): Transcribir el audio que contiene el discurso con significado implícito a texto usando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio donde el significado depende del conocimiento compartido, contexto cultural, o no es completamente literal (por ejemplo, usando un modismo, una pregunta retórica, o haciendo una suposición clara solo por contexto). Se usaimplicit_speech.mp3como marcador de posición. - Función de Transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo la transcripción en texto plano. - Función de Análisis Implícito (
analyze_implicit_meaning):- Maneja el Paso 2, tomando el texto transcrito.
- Ingeniería de Prompts para Significado Implícito: El prompt es clave aquí. Instruye a GPT-4o para mirar más allá de las palabras literales e identificar suposiciones subyacentes, sugerencias implícitas, referencias culturales/modismos, y el propósito detrás de preguntas retóricas.
- Utiliza
gpt-4opor su extensa base de conocimientos y capacidad de razonamiento necesaria para inferir estos elementos implícitos.
- Salida: La función devuelve el análisis textual de GPT-4o de los significados no expresados detectados en el texto de entrada.
- Ejecución Principal: El script transcribe el audio, pasa el texto para análisis implícito, e imprime tanto la transcripción literal como la interpretación de GPT-4o de los significados ocultos.
- Relevancia del Caso de Uso: Esto demuestra cómo GPT-4o puede procesar la comunicación de manera más similar a un humano, entendiendo no solo lo que se dijo, sino también lo que se quiso decir o se asumió. Esto es crucial para aplicaciones que requieren comprensión profunda, como analizar feedback de usuarios, entender diálogos con matices en reuniones, o interpretar contenido culturalmente rico.
Recuerda usar un archivo de audio que contenga habla que requiera cierto nivel de inferencia o conocimiento previo para entenderlo completamente al probar este código. Reemplaza 'implicit_speech.mp3' con tu ruta de archivo.
De la Transcripción a la Comprensión Integral
Este avance marca una transformación revolucionaria en la capacidad de la IA para procesar el habla humana. Mientras que los sistemas tradicionales como Whisper sobresalen en la transcripción - el proceso mecánico de convertir palabras habladas en texto escrito - los sistemas modernos de IA como GPT-4o logran una verdadera comprensión, entendiendo no solo las palabras en sí, sino su significado más profundo, contexto e implicaciones. Este salto adelante permite a la IA procesar la comunicación humana de manera notablemente similar a cómo los humanos entienden naturalmente la conversación, incluyendo sutiles matices, significados implícitos y relevancia contextual.
Para ilustrar esta evolución transformadora en capacidad, examinemos un ejemplo detallado que resalta el marcado contraste entre la simple transcripción y la comprensión avanzada:
- Consideremos esta declaración: "Creo que deberíamos retrasar el lanzamiento del producto hasta el próximo trimestre." Un sistema de transcripción tradicional como Whisper capturaría perfectamente estas palabras, pero ahí es donde termina su comprensión - simplemente convierte el habla a texto con alta precisión.
- GPT-4o, sin embargo, demuestra un nivel sofisticado de comprensión que refleja la comprensión humana:
- Análisis del Mensaje Principal: Más allá de solo identificar la sugerencia de reprogramación, lo entiende como una propuesta estratégica que requiere consideración cuidadosa
- Evaluación del Impacto Empresarial: Evalúa exhaustivamente cómo este retraso afectaría varios aspectos del negocio, desde la asignación de recursos hasta la programación del equipo y las implicaciones presupuestarias
- Análisis Estratégico del Mercado: Examina el contexto más amplio del mercado, incluyendo movimientos de la competencia, tendencias del mercado y potenciales ventanas de oportunidad
- Evaluación Integral de Riesgos: Evalúa las consecuencias tanto inmediatas como a largo plazo, considerando todo, desde la preparación técnica hasta el posicionamiento en el mercado
Lo que hace verdaderamente notable a GPT-4o es su capacidad para participar en discusiones analíticas matizadas sobre el contenido, abordando preguntas estratégicas complejas que requieren comprensión profunda:
- Factores Externos: ¿Qué condiciones específicas del mercado, presiones competitivas o tendencias de la industria podrían haber motivado esta sugerencia de retraso?
- Impacto en los Interesados: ¿Cómo afectaría este ajuste de cronograma las relaciones con inversores, socios y clientes? ¿Qué estrategias de comunicación podrían ser necesarias?
- Oportunidades Estratégicas: ¿Qué ventajas potenciales podrían surgir de este retraso, como desarrollo adicional de características u optimización del momento de lanzamiento al mercado?
2.3.2 ¿Qué puede hacer GPT-4o con entrada de voz?
GPT-4o representa un avance significativo en la tecnología de procesamiento de audio, ofreciendo un conjunto integral de capacidades que transforman cómo interactuamos y entendemos el contenido hablado. Como un modelo de lenguaje de vanguardia con capacidades de procesamiento multimodal, combina reconocimiento sofisticado del habla con comprensión contextual profunda para ofrecer potentes características de análisis de audio. Exploremos algunas otras funciones y capacidades de GPT-4o:
Extracción de Elementos de Acción
Ejemplo de prompt: "Enumera todas las tareas mencionadas en esta nota de voz."
GPT-4o sobresale en identificar y extraer elementos de acción del contenido hablado a través del procesamiento sofisticado del lenguaje natural. El modelo puede:
- Analizar conversaciones complejas para detectar tanto tareas explícitas ("Por favor haz X") como implícitas ("Deberíamos considerar Y")
- Distinguir entre discusiones hipotéticas y compromisos reales
- Categorizar tareas por prioridad, fecha límite y responsable
- Identificar dependencias entre diferentes elementos de acción
- Señalar requisitos de seguimiento y tareas recurrentes
Esta capacidad transforma discusiones de audio no estructuradas en listas de tareas estructuradas y accionables, mejorando significativamente la productividad de las reuniones y el seguimiento. Al mantener automáticamente un registro completo de compromisos, asegura la responsabilidad mientras reduce la carga cognitiva de los participantes que de otro modo necesitarían rastrear estos elementos manualmente. El sistema también puede integrarse con herramientas populares de gestión de tareas, haciendo que sea sencillo convertir asignaciones habladas en tickets o tareas rastreables.
Ejemplo:
Este script utiliza el proceso familiar de dos pasos: primero transcribiendo el audio con Whisper, luego analizando el texto con GPT-4o usando un prompt específicamente diseñado para identificar y estructurar elementos de acción.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/meeting_tasks.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:39 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-24 10:29:00 CDT" # Updated time
current_location = "Plano, Texas, United States"
print(f"Running GPT-4o action item extraction from speech example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_tasks.mp3' with the actual filename.
audio_file_path = "meeting_tasks.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before extraction.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Extract Action Items from Text using GPT-4o ---
def extract_action_items(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for action item extraction."""
print("\nStep 2: Extracting action items...")
if not text_to_analyze:
print("Error: No text provided for extraction.")
return None
# Prompt designed specifically for extracting structured action items
system_prompt = "You are an expert meeting analyst focused on identifying actionable tasks."
user_prompt = f"""Analyze the following meeting or discussion transcription. Identify and extract all specific action items mentioned.
For each action item, provide:
- A clear description of the task.
- The person assigned (if mentioned, otherwise state 'Unassigned' or 'Group').
- Any deadline mentioned (if mentioned, otherwise state 'No deadline mentioned').
Distinguish between definite commitments/tasks and mere suggestions or hypothetical possibilities. Only list items that sound like actual tasks or commitments.
Format the output as a numbered list.
Transcription Text:
---
{text_to_analyze}
---
Extracted Action Items:
"""
try:
print("Sending text to GPT-4o for action item extraction...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong analytical capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=500, # Adjust based on expected number of action items
temperature=0.1 # Very low temperature for factual extraction
)
extracted_actions = response.choices[0].message.content
print("Action item extraction successful.")
return extracted_actions.strip()
except OpenAIError as e:
print(f"OpenAI API Error during extraction: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during extraction: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Extract Action Items
action_items_list = extract_action_items(
client,
full_transcription
)
if action_items_list:
print("\n--- Extracted Action Items ---")
print(action_items_list)
print("------------------------------")
print("\nThis demonstrates GPT-4o identifying and structuring actionable tasks from the discussion.")
else:
print("\nFailed to extract action items.")
else:
print("\nTranscription failed, cannot proceed to action item extraction.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para extraer elementos de acción del contenido hablado. Después de transcribir el audio con Whisper, GPT-4o analiza el texto para identificar tareas específicas, asignaciones y fechas límite discutidas.
- Proceso en dos pasos: Utiliza el flujo de trabajo estándar:
- Paso 1 (Whisper): Transcribe el audio de la reunión/discusión (
client.audio.transcriptions.create) a texto. La nota sobre el manejo de archivos de audio > 25MB mediante segmentación/concatenación sigue siendo crítica para uso real. - Paso 2 (GPT-4o): Analiza la transcripción completa usando
client.chat.completions.createcon un prompt adaptado para la extracción de tareas.
- Paso 1 (Whisper): Transcribe el audio de la reunión/discusión (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio de una reunión donde se asignaron tareas (meeting_tasks.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1. - Función de extracción de elementos de acción (
extract_action_items):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de prompts para tareas: Este es el núcleo. El prompt instruye explícitamente a GPT-4o para identificar elementos de acción, distinguirlos de meras sugerencias, y extraer la descripción de la tarea, la persona asignada (si se menciona), y la fecha límite (si se menciona). Solicita un formato de lista numerada estructurada. Se recomienda una
temperaturemuy baja (por ejemplo, 0.1) para mantener la salida enfocada en la extracción factual. - Utiliza
gpt-4opor su capacidad para entender el contexto conversacional e identificar compromisos.
- Salida: La función devuelve una cadena de texto que contiene la lista estructurada de elementos de acción extraídos.
- Ejecución principal: El script transcribe el audio, pasa el texto a la función de extracción e imprime la lista resultante de tareas.
- Relevancia del caso de uso: Esto aborda directamente la capacidad de "Extracción de elementos de acción". Muestra cómo la IA puede convertir automáticamente discusiones verbales no estructuradas en listas de tareas organizadas y ejecutables. Esto aumenta significativamente la productividad al garantizar el seguimiento, clarificar responsabilidades y reducir el esfuerzo manual de rastrear compromisos hechos durante las reuniones. Destaca la capacidad de GPT-4o para analizar conversaciones complejas e identificar asignaciones de tareas tanto explícitas como implícitas.
Preguntas y respuestas sobre el audio
Ejemplo de prompt: "¿Qué dijo el orador sobre el presupuesto?"
Las capacidades avanzadas de consulta de GPT-4o permiten conversaciones naturales sobre contenido de audio, permitiendo a los usuarios hacer preguntas específicas y recibir respuestas contextualmente relevantes. El modelo puede:
- Extraer información precisa de segmentos específicos
- Comprender el contexto y las referencias a lo largo de todo el audio
- Manejar preguntas de seguimiento sobre temas previamente discutidos
- Proporcionar referencias con marca de tiempo a las partes relevantes
- Hacer referencias cruzadas de información de múltiples partes de la grabación
Esta funcionalidad transforma la forma en que interactuamos con el contenido de audio, haciéndolo tan buscable y consultable como los documentos de texto. En lugar de revisar manualmente las grabaciones, los usuarios pueden simplemente hacer preguntas en lenguaje natural y recibir respuestas precisas y concisas. El sistema es particularmente valioso para:
- Participantes de reuniones que necesitan verificar detalles específicos
- Investigadores analizando grabaciones de entrevistas
- Estudiantes revisando contenido de conferencias
- Profesionales verificando conversaciones con clientes
- Equipos que buscan entender discusiones históricas
Ejemplo:
Este script primero transcribe un archivo de audio usando Whisper y luego utiliza GPT-4o para responder una pregunta específica realizada por el usuario sobre el contenido de esa transcripción.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/meeting_for_qa.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:47 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-01-11 11:47:00 CDT" # Updated time
current_location = "Orlando, Florida, United States"
print(f"Running GPT-4o Q&A about audio example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_for_qa.mp3' with the actual filename.
audio_file_path = "meeting_for_qa.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before Q&A.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Answer Question Based on Text using GPT-4o ---
def answer_question_about_text(client, full_text, question):
"""Sends transcribed text and a question to GPT-4o to get an answer."""
print(f"\nStep 2: Answering question about the transcription...")
print(f"Question: \"{question}\"")
if not full_text:
print("Error: No transcription text provided to answer questions about.")
return None
if not question:
print("Error: No question provided.")
return None
# Prompt designed specifically for answering questions based on provided text
system_prompt = "You are an AI assistant specialized in answering questions based *only* on the provided text transcription. Do not use outside knowledge."
user_prompt = f"""Based *solely* on the following transcription text, please answer the question below. If the answer is not found in the text, state that clearly.
Transcription Text:
---
{full_text}
---
Question: {question}
Answer:
"""
try:
print("Sending transcription and question to GPT-4o...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong comprehension and answering
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=300, # Adjust based on expected answer length
temperature=0.1 # Low temperature for factual answers based on text
)
answer = response.choices[0].message.content
print("Answer generation successful.")
return answer.strip()
except OpenAIError as e:
print(f"OpenAI API Error during Q&A: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during Q&A: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
transcription = transcribe_speech(client, audio_file_path)
if transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(transcription[:1000] + "..." if len(transcription) > 1000 else transcription)
print("------------------------------------")
# --- Ask Questions about the Transcription ---
# Define the question(s) you want to ask
user_question = "What was decided about the email marketing CTA button?"
# user_question = "Who is responsible for the A/B test on Platform B?"
# user_question = "What was the engagement increase on Platform A?"
print(f"\n--- Answering Question ---")
# Step 2: Get the answer from GPT-4o
answer = answer_question_about_text(
client,
transcription,
user_question
)
if answer:
print(f"\nAnswer to '{user_question}':")
print(answer)
print("------------------------------")
print("\nThis demonstrates GPT-4o answering specific questions based on the transcribed audio content.")
else:
print(f"\nFailed to get an answer for the question: '{user_question}'")
else:
print("\nTranscription failed, cannot proceed to Q&A.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para funcionar como un sistema de preguntas y respuestas para contenido de audio. Después de transcribir el habla con Whisper, los usuarios pueden hacer preguntas específicas en lenguaje natural, y GPT-4o proporcionará respuestas basadas en la información contenida en la transcripción.
- Proceso en dos pasos: El flujo de trabajo incluye:
- Paso 1 (Whisper): Transcribir el archivo de audio relevante (o texto concatenado de fragmentos de un archivo más largo) usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): Enviar la transcripción completa junto con la pregunta específica del usuario a
client.chat.completions.create.
- Paso 1 (Whisper): Transcribir el archivo de audio relevante (o texto concatenado de fragmentos de un archivo más largo) usando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que contenga la discusión o información sobre la que el usuario podría hacer preguntas (meeting_for_qa.mp3). La nota crítica sobre el manejo de audio >25MB mediante fragmentación/concatenación antes del paso de preguntas y respuestas sigue siendo esencial. - Función de transcripción (
transcribe_speech): Maneja el Paso 1. - Función de preguntas y respuestas (
answer_question_about_text):- Maneja el Paso 2, tomando tanto la transcripción
full_textcomo laquestioncomo entrada. - Ingeniería de prompt para preguntas y respuestas: El prompt es crucial. Instruye a GPT-4o para que actúe como un asistente especializado que responde preguntas basándose únicamente en el texto de transcripción proporcionado, indicándole explícitamente que no use conocimiento externo y que indique si la respuesta no se encuentra en el texto. Este fundamento es importante para la precisión. Una
temperaturebaja (por ejemplo, 0.1) ayuda a garantizar respuestas factuales derivadas directamente del texto fuente. - Utiliza
gpt-4opor su excelente comprensión lectora y capacidades de preguntas y respuestas.
- Maneja el Paso 2, tomando tanto la transcripción
- Salida: La función devuelve la respuesta de GPT-4o a la pregunta específica realizada.
- Ejecución principal: El script transcribe el audio, define una
user_questionde ejemplo, pasa la transcripción y la pregunta a la función de preguntas y respuestas, e imprime la respuesta resultante. - Relevancia de caso de uso: Esto aborda directamente la capacidad de "Preguntas y respuestas sobre el audio". Transforma las grabaciones de audio de archivos pasivos a fuentes de conocimiento interactivas. Los usuarios pueden encontrar rápidamente detalles específicos, verificar hechos o entender partes de una discusión sin buscar manualmente en el audio, haciéndolo invaluable para revisar reuniones, conferencias, entrevistas o cualquier conversación grabada.
Recuerde usar un archivo de audio que contenga información relevante para las posibles preguntas de prueba (puede usar el audio de muestra proporcionado). Modifique la variable user_question para probar diferentes consultas contra el contenido transcrito.
Destacar momentos clave
Ejemplo de prompt: "Identifique las declaraciones más importantes realizadas en este audio."
GPT-4o sobresale en identificar y extraer momentos cruciales del contenido de audio a través de sus capacidades avanzadas de comprensión del lenguaje natural. El modelo puede:
- Identificar decisiones clave y elementos de acción
- Extraer citas y declaraciones importantes
- Resaltar discusiones estratégicas y conclusiones
- Señalar transiciones críticas en conversaciones
Esta función es particularmente valiosa para:
- Participantes de reuniones que necesitan revisar rápidamente puntos importantes
- Ejecutivos que examinan grabaciones largas en busca de puntos de decisión
- Equipos que rastrean hitos de proyectos discutidos en llamadas
- Investigadores que identifican momentos significativos en entrevistas
El modelo proporciona marcas de tiempo y resúmenes contextuales para cada momento destacado, facilitando la navegación directa a las partes más relevantes de la grabación sin revisar todo el archivo de audio.
Ejemplo:
Este script sigue el patrón establecido de dos pasos: transcribir el audio con Whisper y luego analizar el texto con GPT-4o usando un prompt diseñado para identificar declaraciones significativas, decisiones o conclusiones.
Descargue el audio de ejemplo: https://files.cuantum.tech/audio/key_discussion.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:52 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-02-14 15:52:00 CDT" # Updated time
current_location = "Tampa, Florida, United States"
print(f"Running GPT-4o key moment highlighting example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'key_discussion.mp3' with the actual filename.
audio_file_path = "key_discussion.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before highlighting.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Highlight Key Moments from Text using GPT-4o ---
def highlight_key_moments(client, text_to_analyze):
"""Sends transcribed text to GPT-4o to identify and extract key moments."""
print("\nStep 2: Identifying key moments from transcription...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed specifically for identifying key moments/statements
system_prompt = "You are an expert analyst skilled at identifying the most significant parts of a discussion or presentation."
user_prompt = f"""Analyze the following transcription text. Identify and extract the key moments, which could include:
- Important decisions made
- Critical conclusions reached
- Significant statements or impactful quotes
- Major topic shifts or transitions
- Key questions asked or answered
For each key moment identified, provide the relevant quote or a concise summary of the moment. Present the output as a list.
Transcription Text:
---
{text_to_analyze}
---
Key Moments:
"""
try:
print("Sending text to GPT-4o for key moment identification...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong comprehension
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=700, # Adjust based on expected number/length of key moments
temperature=0.3 # Lean towards factual identification
)
key_moments = response.choices[0].message.content
print("Key moment identification successful.")
return key_moments.strip()
except OpenAIError as e:
print(f"OpenAI API Error during highlighting: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during highlighting: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Highlight Key Moments
highlights = highlight_key_moments(
client,
full_transcription
)
if highlights:
print("\n--- Identified Key Moments ---")
print(highlights)
print("----------------------------")
print("\nThis demonstrates GPT-4o extracting significant parts from the discussion.")
print("\nNote: Adding precise timestamps to these moments requires further processing using Whisper's 'verbose_json' output and correlating the text.")
else:
print("\nFailed to identify key moments.")
else:
print("\nTranscription failed, cannot proceed to highlight key moments.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para Resaltar Momentos Clave del contenido hablado. Después de la transcripción mediante Whisper, GPT-4o analiza el texto para identificar y extraer las partes más significativas, como decisiones cruciales, declaraciones importantes o cambios importantes de tema.
- Proceso en dos pasos:
- Paso 1 (Whisper): Transcribir el audio (
client.audio.transcriptions.create) para obtener el texto completo. Se reitera la necesidad de segmentar/concatenar para archivos de audio > 25MB. - Paso 2 (GPT-4o): Analizar la transcripción completa usando
client.chat.completions.createcon un prompt específicamente diseñado para momentos clave.
- Paso 1 (Whisper): Transcribir el audio (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que contenga una discusión o presentación donde ocurran momentos significativos (key_discussion.mp3). - Función de Transcripción (
transcribe_speech): Maneja el Paso 1. - Función de Resaltado (
highlight_key_moments):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de Prompt para Resaltados: El prompt instruye a GPT-4o a actuar como analista e identificar varios tipos de momentos clave (decisiones, conclusiones, citas impactantes, transiciones). Solicita la cita relevante o un resumen conciso para cada momento identificado, formateado como lista.
- Utiliza
gpt-4opor su capacidad para discernir importancia y contexto dentro del texto.
- Salida: La función devuelve una cadena de texto que contiene la lista de momentos clave identificados.
- Nota sobre Marcas de Tiempo: La explicación y salida del código mencionan explícitamente que mientras este proceso identifica el texto de los momentos clave, agregar marcas de tiempo precisas requeriría pasos adicionales. Esto implica usar el formato
verbose_jsonde Whisper (que incluye marcas de tiempo por segmento) y luego correlacionar el texto identificado por GPT-4o con esos segmentos cronometrados específicos – una tarea más compleja no cubierta en este ejemplo básico. - Ejecución Principal: El script transcribe el audio, pasa el texto a la función de resaltado e imprime la lista resultante de momentos clave.
- Relevancia de Caso de Uso: Esto aborda la capacidad de "Resaltar Momentos Clave" al mostrar cómo la IA puede examinar rápidamente grabaciones potencialmente largas para destacar las partes más críticas. Esto es altamente valioso para la revisión eficiente de reuniones, entrevistas o conferencias, permitiendo a los usuarios enfocarse en lo más importante sin escuchar todo el audio.
Para propósitos de prueba, use un archivo de audio que contenga una discusión relevante con segmentos clave claros e identificables (puede usar el archivo de audio de muestra proporcionado).
2.3.3 Casos de Uso del Mundo Real
El panorama empresarial moderno depende cada vez más de la comunicación por audio en varios sectores, desde ventas y servicio al cliente hasta educación y desarrollo personal. Comprender y utilizar eficazmente estas interacciones de audio se ha vuelto crucial para las organizaciones que buscan mejorar sus operaciones, fortalecer las relaciones con los clientes e impulsar mejores resultados. Esta sección explora varias aplicaciones clave donde el procesamiento y análisis avanzado de audio puede crear un valor significativo, demostrando cómo las herramientas potenciadas por IA pueden transformar datos de audio sin procesar en información procesable.
Desde el análisis de conversaciones de ventas hasta la mejora de experiencias educativas, estos casos de uso muestran la versatilidad y el poder de las tecnologías de comprensión de audio para abordar desafíos del mundo real. Cada aplicación representa una oportunidad única para aprovechar los datos de voz para mejorar la toma de decisiones, optimizar procesos y mejorar las experiencias de usuario.
1. Potenciación de Ventas
El análisis avanzado de grabaciones de llamadas de ventas proporciona un conjunto completo de herramientas para que los equipos de ventas optimicen su rendimiento. El sistema puede identificar objeciones clave planteadas por los prospectos, permitiendo a los equipos desarrollar mejores contraargumentos y preparar respuestas por adelantado. Rastrea técnicas de cierre exitosas analizando patrones en acuerdos exitosos, revelando qué enfoques funcionan mejor para diferentes segmentos de clientes y situaciones.
El sistema también mide métricas cruciales como tasas de conversión, duración de llamadas, proporción de habla-escucha y uso de frases clave. Estos datos ayudan a los equipos de ventas a entender qué comportamientos se correlacionan con resultados exitosos. Al analizar las respuestas de los clientes y patrones de reacción, los equipos pueden refinar el momento de sus presentaciones, mejorar sus técnicas de preguntas y comprender mejor las señales de compra.
Esta tecnología también permite a los gerentes de ventas documentar y compartir enfoques efectivos en todo el equipo, creando una base de conocimientos de mejores prácticas para desafíos comunes. Este conocimiento institucional puede ser particularmente valioso para la incorporación de nuevos miembros del equipo y mantener la excelencia consistente en ventas en toda la organización.
2. Inteligencia de Reuniones
El análisis integral de reuniones transforma la manera en que las organizaciones capturan y utilizan el contenido de las reuniones. El sistema va más allá de la transcripción básica al:
- Identificar y categorizar puntos clave de discusión para fácil referencia
- Detectar y extraer automáticamente elementos de acción de las conversaciones
- Asignar responsabilidades a miembros específicos del equipo basado en compromisos verbales
- Crear líneas de tiempo estructuradas y rastrear plazos mencionados durante las reuniones
- Generar listas automatizadas de tareas con clara propiedad y fechas de vencimiento
- Resaltar puntos de decisión y resultados de reuniones
- Proporcionar archivos de reuniones con capacidad de búsqueda para referencia futura
El sistema emplea procesamiento avanzado de lenguaje natural para comprender contexto, relaciones y compromisos expresados durante las conversaciones. Esto permite la creación y asignación automática de tareas, asegurando que nada se pierda. La integración con herramientas de gestión de proyectos permite la automatización fluida del flujo de trabajo, mientras que los recordatorios inteligentes ayudan a mantener a los miembros del equipo responsables de sus compromisos.
3. Soporte al Cliente
El análisis profundo de interacciones de servicio al cliente proporciona información integral sobre la experiencia del cliente y el rendimiento del equipo de soporte. El sistema puede:
- Evaluar el sentimiento del cliente en tiempo real analizando tono, elección de palabras y flujo de conversación
- Categorizar y priorizar automáticamente problemas urgentes basado en detección de palabras clave y análisis de contexto
- Generar métricas detalladas de satisfacción a través del análisis de conversaciones y retroalimentación del cliente
- Rastrear indicadores clave de rendimiento como tiempo de primera respuesta y tiempo de resolución
- Identificar puntos de dolor comunes y problemas recurrentes a través de múltiples interacciones
- Monitorear el rendimiento del agente de soporte y la consistencia en la entrega del servicio
Esto permite a los equipos de soporte mejorar los tiempos de respuesta, identificar problemas tendencia y mantener una calidad de servicio consistente en todas las interacciones. El sistema también puede proporcionar sugerencias automáticas de entrenamiento para agentes de soporte y generar información para la mejora del producto basada en patrones de retroalimentación del cliente.
4. Diario Personal
Transforma las notas de voz en reflexiones estructuradas con análisis de contexto emocional. Utilizando procesamiento avanzado de lenguaje natural, el sistema analiza las grabaciones de voz para detectar estados emocionales, niveles de estrés y sentimiento general a través del tono de voz, elección de palabras y patrones de habla. Esto crea una entrada de diario multidimensional y rica que captura no solo lo que se dijo, sino cómo se expresó.
Las capacidades de seguimiento del estado de ánimo del sistema van más allá de simples clasificaciones positivas/negativas, identificando estados emocionales con matices como entusiasmo, incertidumbre, confianza o preocupación. Al analizar estos patrones a lo largo del tiempo, los usuarios pueden obtener información valiosa sobre su bienestar emocional e identificar desencadenantes o patrones que afectan su estado mental.
Para el seguimiento de objetivos personales, el sistema puede categorizar y etiquetar automáticamente menciones de objetivos, actualizaciones de progreso y contratiempos. Puede generar informes de progreso que muestran el impulso hacia objetivos específicos, destacar obstáculos comunes e incluso sugerir posibles soluciones basadas en estrategias exitosas anteriores. El análisis de tendencias conductuales examina patrones en la toma de decisiones, formación de hábitos y crecimiento personal, proporcionando a los usuarios información práctica para la superación personal.
5. Educación y Práctica de Idiomas
El apoyo integral al aprendizaje de idiomas revoluciona la forma en que los estudiantes practican y mejoran sus habilidades lingüísticas. El sistema proporciona varios beneficios clave:
- Análisis del Habla: Los algoritmos avanzados analizan patrones de pronunciación, detectando variaciones sutiles en fonemas, patrones de acentuación y entonación. Esto ayuda a los estudiantes a entender exactamente dónde su pronunciación difiere de los hablantes nativos.
- Detección de Errores: El sistema identifica no solo errores de pronunciación, sino también errores gramaticales, uso incorrecto de palabras y problemas sintácticos en tiempo real. Esta retroalimentación inmediata ayuda a prevenir la formación de malos hábitos.
- Retroalimentación Personalizada: En lugar de correcciones genéricas, el sistema proporciona retroalimentación contextual que considera el nivel de competencia del estudiante, su idioma nativo y patrones de interferencia comunes específicos de su origen lingüístico.
- Seguimiento del Progreso: Métricas sofisticadas rastrean varios aspectos del desarrollo del lenguaje, incluyendo rango de vocabulario, fluidez al hablar, precisión gramatical y mejora en la pronunciación a lo largo del tiempo. Los informes visuales de progreso ayudan a motivar a los estudiantes e identificar áreas que necesitan atención.
- Aprendizaje Adaptativo: Basado en el análisis de rendimiento, el sistema crea planes de ejercicios personalizados dirigidos a debilidades específicas. Estos pueden incluir ejercicios focalizados de pronunciación, ejercicios gramaticales o actividades de construcción de vocabulario adaptadas a las necesidades del estudiante.
El sistema puede rastrear la mejora a lo largo del tiempo y sugerir ejercicios específicos para las áreas que necesitan mejora, creando un entorno de aprendizaje dinámico y receptivo que se adapta al progreso de cada estudiante.
2.3.4 Consideraciones de Privacidad
La privacidad es primordial al manejar grabaciones de audio. En primer lugar, obtener el consentimiento antes de analizar grabaciones de voz de terceros es un requisito legal y ético crucial. Es esencial asegurar el permiso escrito o documentado de todos los participantes antes de procesar cualquier grabación de voz, ya sean de reuniones, entrevistas, llamadas u otro contenido de audio que involucre a terceros. Las organizaciones deben implementar un proceso formal de consentimiento que describa claramente cómo se utilizará y analizará el audio.
Se deben implementar medidas de seguridad a lo largo del flujo de trabajo de procesamiento. Después de completar el análisis, es crítico usar openai.files.delete(file_id) para eliminar los archivos de audio de los servidores de OpenAI. Esta práctica minimiza la exposición de datos y ayuda a prevenir el acceso no autorizado y posibles violaciones de datos. Las organizaciones deben establecer procedimientos automatizados de limpieza para asegurar la eliminación consistente de archivos procesados.
El almacenamiento a largo plazo de datos de voz requiere consideración especial. Nunca almacene grabaciones de voz sensibles sin la aprobación explícita de todas las partes involucradas. Las organizaciones deben implementar políticas estrictas de manejo de datos que especifiquen claramente la duración del almacenamiento, medidas de seguridad y uso previsto. Se debe tener especial cuidado con las grabaciones que contengan información personal, secretos comerciales o discusiones confidenciales. Las mejores prácticas incluyen implementar encriptación para archivos de audio almacenados y mantener registros detallados de acceso.
2.3 Comprensión del Habla en GPT-4o
En esta sección, descubrirás cómo trabajar con capacidades avanzadas de procesamiento de audio que van más allá de la transcripción básica. GPT-4o introduce un enfoque revolucionario para la comprensión del audio al permitir la integración directa de archivos de audio junto con indicaciones textuales. Esto crea un sistema de interacción multimodal fluido donde tanto las entradas de audio como de texto se procesan simultáneamente. El sistema puede analizar varios aspectos del habla, incluyendo el tono, el contexto y el significado semántico, permitiéndote construir asistentes inteligentes sofisticados que pueden escuchar, comprender y responder naturalmente dentro de cualquier contexto dado.
La tecnología representa un avance significativo en el procesamiento de audio al combinar la transcripción estilo Whisper con las capacidades avanzadas de razonamiento de GPT-4o. Mientras que Whisper sobresale en la conversión del habla a texto, GPT-4o va más allá al realizar un análisis profundo del contenido transcrito. Esta integración ocurre en una interacción fluida, eliminando la necesidad de pasos de procesamiento separados. Por ejemplo, al procesar la grabación de una reunión de negocios, GPT-4o puede simultáneamente transcribir el habla, identificar hablantes, extraer elementos de acción y generar resúmenes, todo mientras mantiene el contexto y comprende los matices sutiles en la comunicación.
Esta poderosa combinación abre posibilidades sin precedentes para crear aplicaciones de IA más intuitivas y receptivas. Estas aplicaciones no solo pueden procesar y comprender el lenguaje hablado, sino que también pueden interpretar el contexto, la emoción y la intención de formas que anteriormente no eran posibles. Ya sea analizando llamadas de servicio al cliente, procesando conferencias educativas o facilitando la comunicación multilingüe, el sistema proporciona una comprensión integral del contenido hablado que va mucho más allá de la simple transcripción.
2.3.1 ¿Por qué GPT-4o para el Habla?
Mientras que la API de Whisper sobresale en convertir el lenguaje hablado en texto escrito, GPT-4o representa un salto revolucionario en las capacidades de procesamiento de audio. Para entender la distinción, imagina a Whisper como un transcriptor altamente capacitado que puede escribir con precisión cada palabra hablada, mientras que GPT-4o funciona más como un analista experimentado con una profunda comprensión contextual.
Las capacidades de GPT-4o se extienden mucho más allá de la transcripción básica. Puede comprender y procesar el habla en múltiples niveles simultáneamente:
Comprensión Semántica
Comprende el significado real detrás de las palabras, yendo más allá de la traducción palabra por palabra. Esta capacidad avanzada permite a GPT-4o procesar el lenguaje en múltiples niveles simultáneamente, entendiendo no solo el significado literal sino también las capas semánticas más profundas, el contexto cultural y el mensaje pretendido. Esto incluye la comprensión de modismos, metáforas, referencias culturales y expresiones regionales dentro del habla, así como la detección de matices sutiles en la comunicación que podrían perderse en una simple transcripción.
Por ejemplo, cuando alguien dice "está lloviendo a cántaros", GPT-4o entiende que significa una lluvia intensa en lugar de interpretar literalmente que caen cántaros del cielo. De manera similar, al procesar frases como "mucha mierda" antes de una actuación o "pan comido" para describir una tarea fácil, el sistema interpreta correctamente estas expresiones idiomáticas dentro de su contexto cultural.
También puede captar conceptos complejos como el sarcasmo ("Oh, genial, otra reunión"), el humor ("¿Por qué cruzó el modelo GPT la calle?"), y preguntas retóricas ("¿Quién no querría eso?"), haciéndolo capaz de comprender verdaderamente la comunicación humana en todo su contexto. Esta comprensión sofisticada se extiende a referencias culturales específicas, jerga profesional e incluso variaciones dialectales regionales, asegurando una interpretación precisa independientemente del origen o estilo de comunicación del hablante.
Ejemplo:
Dado que la interacción estándar de la API de OpenAI para esto típicamente involucra primero convertir el habla a texto (usando Whisper) y después analizar ese texto para un significado más profundo (usando GPT-4o), el ejemplo de código demostrará este proceso de dos pasos.
Este script:
- Transcribirá un archivo de audio que contiene lenguaje potencialmente matizado usando Whisper.
- Enviará el texto transcrito a GPT-4o con una indicación solicitando interpretación semántica.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/idiom_speech.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:37 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-04-21 19:37:00 CDT"
current_location = "Dallas, Texas, United States"
print(f"Running GPT-4o semantic speech understanding example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with nuanced speech
# IMPORTANT: Replace 'idiom_speech.mp3' with the actual filename.
# Good examples for audio content: "Wow, that presentation just knocked my socks off!",
# "Sure, I'd LOVE to attend another three-hour meeting.", "He really spilled the beans."
audio_file_path = "idiom_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Text for Semantic Meaning using GPT-4o ---
def analyze_text_meaning(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for semantic analysis."""
print(f"\nStep 2: Analyzing text for semantic meaning: \"{text_to_analyze}\"")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Construct prompt to ask for deeper meaning
system_prompt = "You are an expert in linguistics and communication."
user_prompt = (
f"Analyze the following phrase or sentence:\n\n'{text_to_analyze}'\n\n"
"Explain its likely intended meaning, considering context, idioms, "
"metaphors, sarcasm, humor, cultural references, or other nuances. "
"Go beyond a literal, word-for-word interpretation."
)
try:
print("Sending text to GPT-4o for analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for its strong understanding capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=250, # Adjust as needed
temperature=0.5 # Lower temperature for more focused analysis
)
analysis = response.choices[0].message.content
print("Semantic analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\nTranscription Result: {transcribed_text}")
# Step 2: Analyze the transcription for meaning
semantic_analysis = analyze_text_meaning(client, transcribed_text)
if semantic_analysis:
print("\n--- Semantic Analysis Result ---")
print(semantic_analysis)
print("--------------------------------\n")
print("This demonstrates GPT-4o understanding nuances beyond literal text.")
else:
print("\nSemantic analysis failed.")
else:
print("\nTranscription failed, cannot proceed to analysis.")Desglose del código:
- Contexto: Este código demuestra la comprensión semántica avanzada del habla de GPT-4o. Va más allá de la simple transcripción al interpretar el significado, incluyendo matices como modismos, sarcasmo o frases dependientes del contexto.
- Proceso en dos pasos: El ejemplo utiliza un enfoque estándar de API en dos etapas:
- Paso 1 (Whisper): El archivo de audio se convierte primero en texto utilizando la API de Whisper (
client.audio.transcriptions.create). Esto captura las palabras habladas con precisión. - Paso 2 (GPT-4o): El texto transcrito se envía luego al modelo GPT-4o (
client.chat.completions.create) con una instrucción específica solicitando el análisis del significado detrás de las palabras, considerando interpretaciones no literales.
- Paso 1 (Whisper): El archivo de audio se convierte primero en texto utilizando la API de Whisper (
- Requisitos previos: Requiere la configuración estándar de
openaiypython-dotenv, clave API y, fundamentalmente, un archivo de audio que contenga habla con ciertos matices (por ejemplo, que incluya un modismo como "poner las cartas sobre la mesa", un comentario sarcástico como "Qué bien, otra reunión", o una frase culturalmente específica). - Función de transcripción (
transcribe_speech): Esta función maneja el Paso 1, tomando la ruta del archivo de audio y devolviendo la transcripción en texto plano de Whisper. - Función de análisis semántico (
analyze_text_meaning):- Esta función maneja el Paso 2. Recibe el texto transcrito.
- Diseño de la instrucción: Construye una instrucción específicamente pidiendo a GPT-4o que actúe como experto lingüístico y explique el significado pretendido, considerando modismos, sarcasmo, contexto, etc., solicitando explícitamente un análisis más allá de la interpretación literal.
- Utiliza
gpt-4ocomo modelo por sus sólidas capacidades de razonamiento y comprensión. - Devuelve el análisis proporcionado por GPT-4o.
- Ejecución principal: El script primero transcribe el audio. Si tiene éxito, pasa el texto a la función de análisis. Finalmente, imprime tanto la transcripción literal como la interpretación semántica de GPT-4o.
- Relevancia del caso de uso: Este ejemplo muestra claramente cómo la combinación de Whisper y GPT-4o permite una comprensión más profunda del lenguaje hablado que la simple transcripción. Demuestra la capacidad descrita – comprender modismos ("llover a cántaros"), sarcasmo, humor y contexto – haciendo que la interacción con la IA esté más alineada con la comunicación humana.
Recuerda usar un archivo de audio que contenga lenguaje no literal para las pruebas para mostrar mejor el paso de análisis semántico. Reemplaza 'idiom_speech.mp3' con tu ruta de archivo real.
Análisis Contextual
Interpreta las declaraciones dentro de su contexto más amplio, teniendo en cuenta la información circundante, discusiones previas, referencias culturales y factores situacionales. Esto incluye entender cómo el tiempo, lugar, relaciones entre hablantes y conversaciones previas influyen en el significado. El análisis considera múltiples capas de contexto:
- Contexto temporal: Cuándo se dice algo (hora del día, día de la semana, temporada o período histórico)
- Contexto social: Las relaciones entre hablantes, dinámicas de poder y normas sociales
- Contexto físico: La ubicación y el entorno donde ocurre la comunicación
- Contexto cultural: Conocimientos, creencias y costumbres compartidas que influyen en la interpretación
Por ejemplo, la frase "se está haciendo tarde" podría significar diferentes cosas en diferentes contextos:
- Durante una reunión de trabajo: Una sugerencia cortés para concluir la discusión
- En una reunión social: Una indicación de que alguien necesita irse
- De un padre a un hijo: Un recordatorio sobre la hora de dormir
- En una discusión de proyecto: Preocupación por plazos que se aproximan
GPT-4o analiza estas pistas contextuales junto con factores adicionales como el tono de voz, patrones de habla e historial de conversación para proporcionar interpretaciones más precisas y matizadas de la comunicación hablada. Esta comprensión contextual profunda permite al sistema captar el verdadero significado pretendido detrás de las palabras, más allá de su interpretación literal.
Ejemplo:
Este caso de uso se centra en la capacidad de GPT-4o para interpretar el habla transcrita dentro de su contexto más amplio (temporal, social, físico, cultural). Como en el ejemplo de comprensión semántica, esto típicamente involucra un proceso de dos pasos: transcribir el habla con Whisper, luego analizar el texto con GPT-4o, pero esta vez proporcionando explícitamente información contextual a GPT-4o.
Este ejemplo de código:
- Transcribirá una frase simple dependiente del contexto desde un archivo de audio usando Whisper.
- Enviará el texto transcrito a GPT-4o múltiples veces, cada vez proporcionando un contexto diferente.
- Mostrará cómo la interpretación de GPT-4o de la misma frase cambia según el contexto proporcionado.
Descarga el audio de ejemplo: https://files.cuantum.tech/audio/context_phrase.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:44 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-02-11 11:44:00 CDT" # Updated time
current_location = "Miami, Florida, United States"
print(f"Running GPT-4o contextual speech analysis example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with the context-dependent phrase
# IMPORTANT: Replace 'context_phrase.mp3' with the actual filename.
# The audio content should ideally be just "It's getting late."
audio_file_path = "context_phrase.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from the previous example (gpt4o_speech_semantic_py)
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Text for Meaning WITHIN a Given Context using GPT-4o ---
def analyze_text_with_context(client, text_to_analyze, context_description):
"""Sends transcribed text and context description to GPT-4o for analysis."""
print(f"\nStep 2: Analyzing text \"{text_to_analyze}\" within context...")
print(f"Context Provided: {context_description}")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
if not context_description:
print("Error: Context description must be provided for this analysis.")
return None
# Construct prompt asking for interpretation based on context
system_prompt = "You are an expert in analyzing communication and understanding context."
user_prompt = (
f"Consider the phrase: '{text_to_analyze}'\n\n"
f"Now, consider the specific context in which it was said: '{context_description}'\n\n"
"Based *only* on this context, explain the likely intended meaning, implication, "
"or function of the phrase in this situation."
)
try:
print("Sending text and context to GPT-4o for analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong contextual reasoning
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=200, # Adjust as needed
temperature=0.3 # Lower temperature for more focused contextual interpretation
)
analysis = response.choices[0].message.content
print("Contextual analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio phrase
transcribed_phrase = transcribe_speech(client, audio_file_path)
if transcribed_phrase:
print(f"\nTranscription Result: \"{transcribed_phrase}\"")
# Define different contexts for the same phrase
contexts = [
"Said during a business meeting scheduled to end at 5:00 PM, spoken at 4:55 PM.",
"Said by a guest at a social party around 1:00 AM.",
"Said by a parent to a young child at 9:00 PM on a school night.",
"Said during a critical project discussion about an upcoming deadline, spoken late in the evening.",
"Said by someone looking out the window on a short winter afternoon."
]
print("\n--- Analyzing Phrase in Different Contexts ---")
# Step 2: Analyze the phrase within each context
for i, context in enumerate(contexts):
print(f"\n--- Analysis for Context {i+1} ---")
contextual_meaning = analyze_text_with_context(
client,
transcribed_phrase,
context
)
if contextual_meaning:
print(f"Meaning in Context: {contextual_meaning}")
else:
print("Contextual analysis failed for this context.")
print("------------------------------------")
print("\nThis demonstrates how GPT-4o interprets the same phrase differently based on provided context.")
else:
print("\nTranscription failed, cannot proceed to contextual analysis.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para el análisis contextual del habla. Muestra cómo la interpretación de una frase hablada puede cambiar drásticamente según la situación circundante (factores temporales, sociales y situacionales).
- Proceso de dos pasos con inyección de contexto:
- Paso 1 (Whisper): El archivo de audio que contiene una frase dependiente del contexto (por ejemplo, "Se está haciendo tarde") se transcribe a texto usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): El texto transcrito se envía entonces a GPT-4o (
client.chat.completions.create), pero de manera crucial, el prompt ahora incluye una descripción del contexto específico en el que se pronunció la frase.
- Paso 1 (Whisper): El archivo de audio que contiene una frase dependiente del contexto (por ejemplo, "Se está haciendo tarde") se transcribe a texto usando
- Requisitos previos: Requiere la configuración estándar de
openaiypython-dotenv, clave API, y un archivo de audio que contenga una frase simple cuyo significado dependa en gran medida del contexto (el ejemplo usa "Se está haciendo tarde"). - Función de transcripción (
transcribe_speech): Esta función (reutilizada del ejemplo anterior) maneja el Paso 1. - Función de análisis contextual (
analyze_text_with_context):- Esta función maneja el Paso 2 y ahora acepta un argumento adicional:
context_description. - Diseño del prompt: El prompt proporciona explícitamente tanto la frase transcrita como la
context_descriptiona GPT-4o, pidiéndole que interprete la frase dentro de esa situación específica. - Utiliza
gpt-4opor su capacidad de razonar basándose en el contexto proporcionado.
- Esta función maneja el Paso 2 y ahora acepta un argumento adicional:
- Demostración de la dependencia del contexto (Ejecución principal):
- El script primero transcribe la frase (por ejemplo, "Se está haciendo tarde").
- Luego define una lista de diferentes descripciones de contexto (finalización de reunión, fiesta nocturna, hora de dormir, fecha límite de proyecto, día corto de invierno).
- Llama a la función
analyze_text_with_contextrepetidamente, usando la misma frase transcrita pero proporcionando una descripción de contexto diferente cada vez. - Al imprimir el resultado del análisis para cada contexto, el script muestra claramente cómo la interpretación de GPT-4o cambia según el contexto proporcionado (por ejemplo, sugiriendo concluir vs. indicando cansancio vs. notando la disminución de la luz del día).
- Relevancia del caso de uso: Esto destaca la comprensión sofisticada de GPT-4o, yendo más allá de las palabras literales para captar el significado pretendido influenciado por factores temporales, sociales y situacionales. Esto es vital para aplicaciones que necesitan una interpretación precisa de la comunicación en el mundo real en negocios, interacciones sociales o cualquier entorno rico en contexto. Muestra cómo los desarrolladores pueden proporcionar contexto relevante junto con el texto transcrito para obtener interpretaciones más precisas y matizadas de la IA.
Para probar este código efectivamente, crea un archivo de audio que contenga solo la frase "Se está haciendo tarde" (u otra frase dependiente del contexto), o descarga el archivo de muestra proporcionado. Recuerda actualizar la ruta 'context_phrase.mp3' para que coincida con la ubicación de tu archivo.
Generación de resúmenes
Las capacidades de generación de resúmenes de GPT-4o representan un avance significativo en el análisis de contenido impulsado por IA. El sistema crea resúmenes concisos y significativos de discusiones complejas mediante la destilación inteligente de información clave de conversaciones, reuniones o presentaciones extensas. Utilizando procesamiento avanzado del lenguaje natural y comprensión contextual, GPT-4o puede identificar temas principales, puntos críticos y conclusiones esenciales mientras mantiene el significado central y el contexto de la discusión original.
El sistema emplea varias técnicas sofisticadas:
- Reconocimiento de patrones: Identifica temas recurrentes y puntos importantes de discusión a lo largo de conversaciones extensas
- Análisis contextual: Comprende el contexto más amplio y las relaciones entre diferentes partes de la discusión
- Detección de prioridades: Determina automáticamente qué información es más crucial para el resumen
- Comprensión semántica: Capta significados subyacentes e implicaciones más allá del contenido superficial
Los resúmenes generados pueden personalizarse para diferentes propósitos y audiencias:
- Informes ejecutivos: Enfocados en perspectivas estratégicas y decisiones de alto nivel
- Actas de reuniones: Documentación detallada de discusiones y elementos de acción
- Resúmenes rápidos: Aspectos destacados condensados para consumo rápido de información
- Resúmenes técnicos: Énfasis en detalles técnicos específicos y especificaciones
Lo que distingue a GPT-4o es su capacidad para preservar detalles importantes mientras reduce significativamente la sobrecarga de información, convirtiéndolo en una herramienta invaluable para la comunicación empresarial moderna y la gestión del conocimiento.
Ejemplo:
Este ejemplo se centra en la capacidad de GPT-4o para generar resúmenes concisos y significativos de contenido hablado potencialmente extenso obtenido a través de Whisper.
Esto involucra el proceso familiar de dos pasos: primero, transcribir el audio con Whisper para obtener el texto completo, y segundo, usar las capacidades de comprensión del lenguaje de GPT-4o para analizar y resumir ese texto según necesidades específicas. Este ejemplo demostrará la generación de diferentes tipos de resúmenes a partir de la misma transcripción.
Descarga el audio de muestra: https://files.cuantum.tech/audio/discussion_audio.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:59 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-04-10 15:59:00 CDT" # Updated time
current_location = "Houston, Texas, United States"
print(f"Running GPT-4o speech summarization example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'discussion_audio.mp3' with the actual filename.
audio_file_path = "discussion_audio.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before summarization.")
except OSError:
pass # Ignore size check error, proceed with transcription attempt
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Generate Summary from Text using GPT-4o ---
def summarize_text(client, text_to_summarize, summary_style="concise overview"):
"""Sends transcribed text to GPT-4o for summarization."""
print(f"\nStep 2: Generating '{summary_style}' summary...")
if not text_to_summarize:
print("Error: No text provided for summarization.")
return None
# Tailor the prompt based on the desired summary style
system_prompt = "You are an expert meeting summarizer and information distiller."
user_prompt = f"""Please generate a {summary_style} of the following discussion transcription.
Focus on accurately capturing the key information relevant to a {summary_style}. For example:
- For an 'executive briefing', focus on strategic points, decisions, and outcomes.
- For 'detailed meeting minutes', include main topics, key arguments, decisions, and action items.
- For a 'concise overview', provide the absolute main points and purpose.
- For a 'technical summary', emphasize technical details, specifications, or findings.
Transcription Text:
---
{text_to_summarize}
---
Generate the {summary_style}:
"""
try:
print(f"Sending text to GPT-4o for {summary_style}...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong summarization
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=400, # Adjust based on expected summary length
temperature=0.5 # Balance creativity and focus
)
summary = response.choices[0].message.content
print(f"'{summary_style}' generation successful.")
return summary.strip()
except OpenAIError as e:
print(f"OpenAI API Error during summarization: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during summarization: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("--------------------------")
# Step 2: Generate summaries in different styles
summary_styles_to_generate = [
"concise overview",
"detailed meeting minutes with action items",
"executive briefing focusing on decisions",
# "technical summary" # Add if relevant to your audio content
]
print("\n--- Generating Summaries ---")
for style in summary_styles_to_generate:
print(f"\n--- Summary Style: {style} ---")
summary_result = summarize_text(
client,
full_transcription,
summary_style=style
)
if summary_result:
print(summary_result)
else:
print(f"Failed to generate '{style}'.")
print("------------------------------------")
print("\nThis demonstrates GPT-4o generating different summaries from the same transcription based on the prompt.")
else:
print("\nTranscription failed, cannot proceed to summarization.")Desglose del código:
- Contexto: Este código demuestra la capacidad avanzada de GPT-4o para generar resúmenes de contenido hablado. Utiliza un proceso de dos pasos: transcribir el audio con Whisper y luego usar GPT-4o para destilar inteligentemente la información clave de la transcripción en un resumen conciso.
- Manejo de Audio Extenso (Nota Crucial): Los prerrequisitos y comentarios del código abordan explícitamente el límite de 25MB de la API de Whisper. Para reuniones o presentaciones largas del mundo real, el audio debe ser dividido en fragmentos, cada fragmento transcrito por separado, y los textos resultantes concatenados antes de ser enviados al paso de resumen. El ejemplo de código procesa un solo archivo de audio por simplicidad, pero destaca este flujo de trabajo esencial para contenido más largo.
- Prerrequisitos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que representa la discusión a resumir (discussion_audio.mp3). - Función de Transcripción (
transcribe_speech): Maneja el Paso 1, convirtiendo el audio de entrada (o fragmento de audio) en texto plano usando Whisper. - Función de Resumen (
summarize_text):- Maneja el Paso 2, tomando el texto transcrito completo como entrada.
- Resúmenes Personalizables: Acepta un argumento
summary_style(por ejemplo, "informe ejecutivo", "actas detalladas de reunión"). - Ingeniería de Prompt: El prompt enviado a GPT-4o se construye dinámicamente según el
summary_stylesolicitado. Instruye a GPT-4o para actuar como un experto en resúmenes y adaptar la salida (enfocándose en puntos estratégicos, elementos de acción, detalles técnicos, etc.) según el estilo deseado. - Utiliza
gpt-4opor sus avanzadas capacidades de comprensión y resumen.
- Demostración de Diferentes Tipos de Resumen (Ejecución Principal):
- El script primero obtiene la transcripción completa.
- Luego define una lista de diferentes
summary_styles_to_generate. - Llama a la función
summarize_textmúltiples veces, pasando la misma transcripción completa cada vez pero variando el argumentosummary_style. - Al imprimir cada resumen resultante, el script muestra claramente cómo GPT-4o adapta el nivel de detalle y enfoque según el prompt, generando salidas distintas (por ejemplo, una visión general breve vs. actas detalladas) del mismo texto fuente.
- Relevancia de Caso de Uso: Esto aborda directamente la capacidad de "Generación de Resúmenes". Muestra cómo la combinación de Whisper y GPT-4o puede transformar discusiones habladas extensas en varios formatos útiles (informes ejecutivos, actas de reuniones, resúmenes rápidos), ahorrando tiempo y mejorando la gestión del conocimiento en negocios, educación y creación de contenido.
Extracción de Puntos Clave
Identifica y destaca información crucial aprovechando las capacidades avanzadas de procesamiento del lenguaje natural de GPT-4o. A través de algoritmos sofisticados y comprensión contextual, el modelo analiza contenido hablado para extraer ideas significativas. El modelo puede:
- Extraer conceptos centrales y argumentos principales del contenido hablado - Esto implica identificar las ideas fundamentales, mensajes clave y evidencia de respaldo presentada en conversaciones, presentaciones o discusiones. El modelo distingue entre puntos primarios y secundarios, asegurando que se capture la información esencial.
- Identificar puntos de decisión críticos y elementos de acción - Al analizar el flujo de la conversación y el contexto, GPT-4o reconoce momentos cuando se toman decisiones, se establecen compromisos o se asignan tareas. Esto incluye detectar tanto asignaciones explícitas ("John se encargará de esto") como implícitas ("Deberíamos investigar esto más a fondo").
- Priorizar información basada en contexto y relevancia - El modelo evalúa la importancia de diferentes piezas de información dentro de su contexto específico, considerando factores como urgencia, impacto y relación con los objetivos generales. Esto ayuda a crear resúmenes jerárquicos que enfatizan lo más importante.
- Seguir temas clave y tópicos recurrentes a través de conversaciones - GPT-4o mantiene consciencia de patrones de discusión, identificando cuando ciertos temas resurgen y cómo evolucionan con el tiempo. Esta capacidad es particularmente valiosa para el monitoreo de proyectos a largo plazo o el seguimiento de preocupaciones continuas a través de múltiples reuniones.
Ejemplo:
Este ejemplo se centra en usar GPT-4o para extraer información específica y crucial—puntos clave, decisiones, elementos de acción—del habla transcrita, yendo más allá de un resumen general.
Esto nuevamente utiliza el enfoque de dos pasos: Whisper transcribe el audio, y luego GPT-4o analiza el texto basado en un prompt diseñado para extracción.
Descarga la muestra de audio: https://files.cuantum.tech/audio/meeting_for_extraction.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:07 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-21 22:07:00 CDT" # Updated time
current_location = "Austin, Texas, United States"
print(f"Running GPT-4o key point extraction from speech example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_for_extraction.mp3' with the actual filename.
audio_file_path = "meeting_for_extraction.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before extraction.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Extract Key Points, Decisions, Actions using GPT-4o ---
def extract_key_points(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for key point extraction."""
print("\nStep 2: Extracting key points, decisions, and actions...")
if not text_to_analyze:
print("Error: No text provided for extraction.")
return None
# Prompt designed specifically for extraction
system_prompt = "You are an expert meeting analyst. Your task is to carefully read the provided transcript and extract specific types of information."
user_prompt = f"""Analyze the following meeting or discussion transcription. Identify and extract the following information, presenting each under a clear heading:
1. **Key Points / Core Concepts:** List the main topics, arguments, or fundamental ideas discussed.
2. **Decisions Made:** List any clear decisions that were reached during the discussion.
3. **Action Items:** List specific tasks assigned to individuals or the group. If possible, note who is responsible and any mentioned deadlines.
If any category has no relevant items, state "None identified".
Transcription Text:
---
{text_to_analyze}
---
Extracted Information:
"""
try:
print("Sending text to GPT-4o for extraction...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong analytical capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=600, # Adjust based on expected length of extracted info
temperature=0.2 # Lower temperature for more factual extraction
)
extracted_info = response.choices[0].message.content
print("Extraction successful.")
return extracted_info.strip()
except OpenAIError as e:
print(f"OpenAI API Error during extraction: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during extraction: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Extract Key Information
extracted_details = extract_key_points(
client,
full_transcription
)
if extracted_details:
print("\n--- Extracted Key Information ---")
print(extracted_details)
print("---------------------------------")
print("\nThis demonstrates GPT-4o identifying and structuring key takeaways from the discussion.")
else:
print("\nFailed to extract key information.")
else:
print("\nTranscription failed, cannot proceed to key point extraction.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para extraer puntos clave del contenido hablado. Después de transcribir el audio usando Whisper, GPT-4o analiza el texto para identificar y aislar información crucial como conceptos fundamentales, decisiones tomadas y elementos de acción asignados.
- Proceso de dos pasos: Al igual que la sumarización, esto se basa en:
- Paso 1 (Whisper): Transcripción del audio (
client.audio.transcriptions.create) para obtener el texto completo. La nota crítica sobre el manejo de archivos de audio mayores a 25MB mediante segmentación y concatenación sigue siendo aplicable. - Paso 2 (GPT-4o): Análisis de la transcripción completa usando
client.chat.completions.createcon un prompt específicamente diseñado para la extracción.
- Paso 1 (Whisper): Transcripción del audio (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio de una reunión o discusión donde es probable que haya información clave (meeting_for_extraction.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo la transcripción en texto plano. - Función de extracción (
extract_key_points):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de prompt para extracción: Esto es clave. El prompt instruye explícitamente a GPT-4o a actuar como analista y extraer información bajo encabezados específicos: "Puntos Clave / Conceptos Fundamentales", "Decisiones Tomadas" y "Elementos de Acción". Esta solicitud estructurada guía a GPT-4o para identificar y categorizar la información relevante con precisión. Se sugiere una
temperaturemás baja (por ejemplo, 0.2) para fomentar una salida más factual y menos creativa, adecuada para la extracción. - Utiliza
gpt-4opor sus avanzadas capacidades analíticas.
- Salida: La función devuelve una cadena de texto que contiene la información extraída, estructurada idealmente bajo los encabezados solicitados.
- Ejecución principal: El script transcribe el audio, luego pasa el texto a la función de extracción, y finalmente imprime la salida estructurada.
- Relevancia del caso de uso: Esto aborda directamente la capacidad de "Extracción de Puntos Clave". Demuestra cómo la IA puede procesar automáticamente discusiones extensas para extraer los conceptos más importantes, rastrear decisiones y listar tareas accionables, ahorrando tiempo significativo en la revisión de grabaciones o generación de seguimientos de reuniones. Destaca la capacidad de GPT-4o para comprender el flujo conversacional e identificar momentos significativos (decisiones, asignaciones) dentro del texto.
Inteligencia Emocional
Detecta el tono, el sentimiento y los matices emocionales en la comunicación hablada a través de las capacidades avanzadas de procesamiento del lenguaje natural de GPT-4o. Este sofisticado sistema realiza un análisis profundo de los patrones del habla y elementos contextuales para comprender las capas emocionales de la comunicación. El modelo puede identificar señales emocionales sutiles como:
- Inflexiones y patrones de voz que indican emoción, duda o preocupación - Incluyendo variaciones de tono, cambios en el ritmo del habla y patrones de estrés vocal que los humanos utilizan naturalmente para transmitir emociones
- Cambios en el tempo y volumen del habla que sugieren estados emocionales - Por ejemplo, un habla rápida podría indicar emoción o ansiedad, mientras que un habla más lenta podría sugerir reflexión o incertidumbre
- Marcadores emocionales contextuales como risas, suspiros o pausas - El modelo reconoce sonidos no verbales y silencios que transmiten significado emocional importante en la conversación
- Matices culturales y situacionales que afectan la expresión emocional - Comprensión de cómo diferentes culturas expresan las emociones de manera diferente y cómo el contexto influye en la interpretación emocional
Esta conciencia emocional permite a GPT-4o proporcionar respuestas más matizadas y apropiadas al contexto, haciéndolo particularmente valioso para aplicaciones en servicio al cliente (donde entender la frustración o satisfacción del cliente es crucial), conversaciones terapéuticas (donde el apoyo emocional y la comprensión son primordiales), y coaching personal (donde la motivación y el crecimiento emocional son objetivos clave). La capacidad del sistema para detectar estas señales emocionales sutiles permite una comunicación más empática y efectiva en diversos contextos profesionales y personales.
Ejemplo:
Este ejemplo explora el uso de GPT-4o para "Inteligencia Emocional" – detectando tono, sentimiento y matices emocionales en el habla.
Es importante entender cómo funciona esto con las APIs estándar actuales de OpenAI. Mientras que GPT-4o sobresale en entender la emoción desde el texto, analizar directamente características de audio como tono, variación de tono, tempo, suspiros o risas como audio no es una función principal de la transcripción estándar de Whisper o del endpoint de Chat Completions API al procesar texto transcrito.
Por lo tanto, la forma más práctica de demostrar este concepto usando estas APIs es un proceso de dos pasos:
- Transcribir Voz a Texto: Usar Whisper para obtener las palabras habladas.
- Analizar Texto para Emociones: Usar GPT-4o para analizar el texto transcrito en busca de indicadores de emoción, sentimiento o tono basados en la elección de palabras, fraseo y contexto descrito en el texto.
Descarga el audio de muestra: https://files.cuantum.tech/audio/emotional_speech.mp3
Este ejemplo de código implementa este enfoque de análisis basado en texto de dos pasos.
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:13 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-21 20:13:00 CDT" # Updated time
current_location = "Atlanta, Georgia, United States"
print(f"Running GPT-4o speech emotion analysis (text-based) example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with potentially emotional speech
# IMPORTANT: Replace 'emotional_speech.mp3' with the actual filename.
audio_file_path = "emotional_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Transcribed Text for Emotion/Sentiment using GPT-4o ---
def analyze_text_emotion(client, text_to_analyze):
"""
Sends transcribed text to GPT-4o for emotion and sentiment analysis.
Note: This analyzes the text content, not acoustic features of the original audio.
"""
print("\nStep 2: Analyzing transcribed text for emotion/sentiment...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed for text-based emotion/sentiment analysis
system_prompt = "You are an expert in communication analysis, skilled at detecting sentiment, tone, and potential underlying emotions from text."
user_prompt = f"""Analyze the following text for emotional indicators:
Text:
---
{text_to_analyze}
---
Based *only* on the words, phrasing, and punctuation in the text provided:
1. What is the overall sentiment (e.g., Positive, Negative, Neutral, Mixed)?
2. What is the likely emotional tone (e.g., Frustrated, Excited, Calm, Anxious, Sarcastic, Happy, Sad)?
3. Are there specific words or phrases that indicate these emotions? Explain briefly.
Provide the analysis:
"""
try:
print("Sending text to GPT-4o for emotion analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for nuanced understanding
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=300, # Adjust as needed
temperature=0.4 # Slightly lower temp for more grounded analysis
)
analysis = response.choices[0].message.content
print("Emotion analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\n--- Transcription Result ---")
print(transcribed_text)
print("----------------------------")
# Step 2: Analyze the transcription for emotion/sentiment
emotion_analysis = analyze_text_emotion(
client,
transcribed_text
)
if emotion_analysis:
print("\n--- Emotion/Sentiment Analysis (from Text) ---")
print(emotion_analysis)
print("----------------------------------------------")
print("\nNote: This analysis is based on the transcribed text content. It does not directly analyze acoustic features like tone of voice from the original audio.")
else:
print("\nEmotion analysis failed.")
else:
print("\nTranscription failed, cannot proceed to emotion analysis.")
# --- End of Code Example ---
Desglose del código:
- Contexto: Este código demuestra cómo GPT-4o puede utilizarse para inferir el tono emocional y el sentimiento del lenguaje hablado. Utiliza un proceso de dos pasos común para este tipo de análisis con las APIs actuales.
- Proceso de dos pasos y limitación:
- Paso 1 (Whisper): Primero, el audio se transcribe a texto utilizando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): El texto resultante es entonces analizado por GPT-4o (
client.chat.completions.create) utilizando un prompt específicamente diseñado para identificar indicadores de sentimiento y emocionales dentro del texto. - Limitación importante: La explicación (y los comentarios del código) deben establecer claramente que este método analiza el contenido lingüístico (palabras, frases) proporcionado por Whisper. No analiza directamente características acústicas del audio original como el tono, tempo, o sonidos no verbales específicos (suspiros, risas) a menos que estos sean transcritos por Whisper (lo cual no suele ocurrir con señales sutiles). La verdadera detección acústica de emociones requeriría diferentes herramientas o APIs.
- Paso 1 (Whisper): Primero, el audio se transcribe a texto utilizando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio donde las palabras del hablante puedan sugerir una emoción (emotional_speech.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo texto plano. - Función de análisis emocional (
analyze_text_emotion):- Maneja el Paso 2, tomando el texto transcrito.
- Diseño del prompt: El prompt solicita explícitamente a GPT-4o que analice el texto proporcionado para determinar el sentimiento general (Positivo/Negativo/Neutral), el probable tono emocional (Frustrado, Emocionado, etc.), y evidencia textual de respaldo. Aclara que el análisis debe basarse únicamente en el texto.
- Utiliza
gpt-4opara su sofisticada comprensión del lenguaje.
- Resultado: La función devuelve el análisis textual de GPT-4o sobre la emoción y el sentimiento inferidos.
- Ejecución principal: El script transcribe el audio, pasa el texto para su análisis, imprime ambos resultados y reitera la limitación respecto a las características acústicas.
- Relevancia de caso de uso: Aunque no analiza la acústica directamente, este enfoque basado en texto sigue siendo valioso para aplicaciones como servicio al cliente (detectando frustración/satisfacción por la elección de palabras), analizando retroalimentación, u obteniendo una sensación general del sentimiento en interacciones habladas, complementando otras formas de análisis. Demuestra la capacidad de GPT-4o para interpretar lenguaje emocional.
Recuerda usar un archivo de audio donde las palabras habladas transmitan alguna emoción para que este ejemplo sea efectivo. Reemplaza 'emotional_speech.mp3' con tu ruta de archivo.
Comprensión implícita
GPT-4o demuestra capacidades notables en la comprensión de las capas más profundas de la comunicación humana, yendo mucho más allá del simple reconocimiento de palabras para captar los matices intrincados del habla. Las sofisticadas habilidades de comprensión del modelo incluyen:
- Detectar contexto y suposiciones subyacentes
- Comprende el conocimiento implícito compartido entre hablantes
- Reconoce hechos no declarados pero comúnmente aceptados dentro de dominios específicos
- Identifica premisas ocultas en conversaciones
- Comprender referencias culturales y expresiones idiomáticas
- Procesa dichos y coloquialismos específicos de cada región
- Reconoce metáforas y analogías específicas de cada cultura
- Adapta la comprensión basándose en el contexto cultural
- Interpretar recursos retóricos
Ejemplo:
Similar a los ejemplos anteriores que involucran comprensión más profunda (Semántica, Contextual, Emocional), esto típicamente utiliza el enfoque de dos pasos: Whisper transcribe las palabras, y luego GPT-4o analiza el texto resultante, esta vez específicamente instruido para buscar capas implícitas.
Descarga el audio de muestra: https://files.cuantum.tech/audio/implicit_speech.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:21 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-12 16:21:00 CDT" # Updated time
current_location = "Dallas, Texas, United States"
print(f"Running GPT-4o implicit speech understanding example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with implicit meaning
# IMPORTANT: Replace 'implicit_speech.mp3' with the actual filename.
audio_file_path = "implicit_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Transcribed Text for Implicit Meaning using GPT-4o ---
def analyze_implicit_meaning(client, text_to_analyze):
"""
Sends transcribed text to GPT-4o to analyze implicit meanings,
assumptions, references, or rhetorical devices.
"""
print("\nStep 2: Analyzing transcribed text for implicit meaning...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed for identifying implicit communication layers
system_prompt = "You are an expert analyst of human communication, skilled at identifying meaning that is implied but not explicitly stated."
user_prompt = f"""Analyze the following statement or question:
Statement/Question:
---
{text_to_analyze}
---
Based on common knowledge, cultural context, and conversational patterns, please explain:
1. Any underlying assumptions the speaker might be making.
2. Any implicit meanings or suggestions conveyed beyond the literal words.
3. Any cultural references, idioms, or sayings being used or alluded to.
4. If it's a rhetorical question, what point is likely being made?
Provide a breakdown of the implicit layers of communication present:
"""
try:
print("Sending text to GPT-4o for implicit meaning analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for deep understanding
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=400, # Adjust as needed
temperature=0.5 # Allow for some interpretation
)
analysis = response.choices[0].message.content
print("Implicit meaning analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\n--- Transcription Result ---")
print(transcribed_text)
print("----------------------------")
# Step 2: Analyze the transcription for implicit meaning
implicit_analysis = analyze_implicit_meaning(
client,
transcribed_text
)
if implicit_analysis:
print("\n--- Implicit Meaning Analysis ---")
print(implicit_analysis)
print("-------------------------------")
print("\nThis demonstrates GPT-4o identifying meaning beyond the literal text, based on common knowledge and context.")
else:
print("\nImplicit meaning analysis failed.")
else:
print("\nTranscription failed, cannot proceed to implicit meaning analysis.")Desglose del código:
- Contexto: Este ejemplo de código demuestra la capacidad de GPT-4o para la Comprensión Implícita – captar las suposiciones no expresadas, referencias y significados integrados en el lenguaje hablado.
- Proceso en dos pasos: Sigue el patrón establecido:
- Paso 1 (Whisper): Transcribir el audio que contiene el discurso con significado implícito a texto usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): Analizar el texto transcrito usando
client.chat.completions.create, con un prompt específicamente diseñado para descubrir capas ocultas de significado.
- Paso 1 (Whisper): Transcribir el audio que contiene el discurso con significado implícito a texto usando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio donde el significado depende del conocimiento compartido, contexto cultural, o no es completamente literal (por ejemplo, usando un modismo, una pregunta retórica, o haciendo una suposición clara solo por contexto). Se usaimplicit_speech.mp3como marcador de posición. - Función de Transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo la transcripción en texto plano. - Función de Análisis Implícito (
analyze_implicit_meaning):- Maneja el Paso 2, tomando el texto transcrito.
- Ingeniería de Prompts para Significado Implícito: El prompt es clave aquí. Instruye a GPT-4o para mirar más allá de las palabras literales e identificar suposiciones subyacentes, sugerencias implícitas, referencias culturales/modismos, y el propósito detrás de preguntas retóricas.
- Utiliza
gpt-4opor su extensa base de conocimientos y capacidad de razonamiento necesaria para inferir estos elementos implícitos.
- Salida: La función devuelve el análisis textual de GPT-4o de los significados no expresados detectados en el texto de entrada.
- Ejecución Principal: El script transcribe el audio, pasa el texto para análisis implícito, e imprime tanto la transcripción literal como la interpretación de GPT-4o de los significados ocultos.
- Relevancia del Caso de Uso: Esto demuestra cómo GPT-4o puede procesar la comunicación de manera más similar a un humano, entendiendo no solo lo que se dijo, sino también lo que se quiso decir o se asumió. Esto es crucial para aplicaciones que requieren comprensión profunda, como analizar feedback de usuarios, entender diálogos con matices en reuniones, o interpretar contenido culturalmente rico.
Recuerda usar un archivo de audio que contenga habla que requiera cierto nivel de inferencia o conocimiento previo para entenderlo completamente al probar este código. Reemplaza 'implicit_speech.mp3' con tu ruta de archivo.
De la Transcripción a la Comprensión Integral
Este avance marca una transformación revolucionaria en la capacidad de la IA para procesar el habla humana. Mientras que los sistemas tradicionales como Whisper sobresalen en la transcripción - el proceso mecánico de convertir palabras habladas en texto escrito - los sistemas modernos de IA como GPT-4o logran una verdadera comprensión, entendiendo no solo las palabras en sí, sino su significado más profundo, contexto e implicaciones. Este salto adelante permite a la IA procesar la comunicación humana de manera notablemente similar a cómo los humanos entienden naturalmente la conversación, incluyendo sutiles matices, significados implícitos y relevancia contextual.
Para ilustrar esta evolución transformadora en capacidad, examinemos un ejemplo detallado que resalta el marcado contraste entre la simple transcripción y la comprensión avanzada:
- Consideremos esta declaración: "Creo que deberíamos retrasar el lanzamiento del producto hasta el próximo trimestre." Un sistema de transcripción tradicional como Whisper capturaría perfectamente estas palabras, pero ahí es donde termina su comprensión - simplemente convierte el habla a texto con alta precisión.
- GPT-4o, sin embargo, demuestra un nivel sofisticado de comprensión que refleja la comprensión humana:
- Análisis del Mensaje Principal: Más allá de solo identificar la sugerencia de reprogramación, lo entiende como una propuesta estratégica que requiere consideración cuidadosa
- Evaluación del Impacto Empresarial: Evalúa exhaustivamente cómo este retraso afectaría varios aspectos del negocio, desde la asignación de recursos hasta la programación del equipo y las implicaciones presupuestarias
- Análisis Estratégico del Mercado: Examina el contexto más amplio del mercado, incluyendo movimientos de la competencia, tendencias del mercado y potenciales ventanas de oportunidad
- Evaluación Integral de Riesgos: Evalúa las consecuencias tanto inmediatas como a largo plazo, considerando todo, desde la preparación técnica hasta el posicionamiento en el mercado
Lo que hace verdaderamente notable a GPT-4o es su capacidad para participar en discusiones analíticas matizadas sobre el contenido, abordando preguntas estratégicas complejas que requieren comprensión profunda:
- Factores Externos: ¿Qué condiciones específicas del mercado, presiones competitivas o tendencias de la industria podrían haber motivado esta sugerencia de retraso?
- Impacto en los Interesados: ¿Cómo afectaría este ajuste de cronograma las relaciones con inversores, socios y clientes? ¿Qué estrategias de comunicación podrían ser necesarias?
- Oportunidades Estratégicas: ¿Qué ventajas potenciales podrían surgir de este retraso, como desarrollo adicional de características u optimización del momento de lanzamiento al mercado?
2.3.2 ¿Qué puede hacer GPT-4o con entrada de voz?
GPT-4o representa un avance significativo en la tecnología de procesamiento de audio, ofreciendo un conjunto integral de capacidades que transforman cómo interactuamos y entendemos el contenido hablado. Como un modelo de lenguaje de vanguardia con capacidades de procesamiento multimodal, combina reconocimiento sofisticado del habla con comprensión contextual profunda para ofrecer potentes características de análisis de audio. Exploremos algunas otras funciones y capacidades de GPT-4o:
Extracción de Elementos de Acción
Ejemplo de prompt: "Enumera todas las tareas mencionadas en esta nota de voz."
GPT-4o sobresale en identificar y extraer elementos de acción del contenido hablado a través del procesamiento sofisticado del lenguaje natural. El modelo puede:
- Analizar conversaciones complejas para detectar tanto tareas explícitas ("Por favor haz X") como implícitas ("Deberíamos considerar Y")
- Distinguir entre discusiones hipotéticas y compromisos reales
- Categorizar tareas por prioridad, fecha límite y responsable
- Identificar dependencias entre diferentes elementos de acción
- Señalar requisitos de seguimiento y tareas recurrentes
Esta capacidad transforma discusiones de audio no estructuradas en listas de tareas estructuradas y accionables, mejorando significativamente la productividad de las reuniones y el seguimiento. Al mantener automáticamente un registro completo de compromisos, asegura la responsabilidad mientras reduce la carga cognitiva de los participantes que de otro modo necesitarían rastrear estos elementos manualmente. El sistema también puede integrarse con herramientas populares de gestión de tareas, haciendo que sea sencillo convertir asignaciones habladas en tickets o tareas rastreables.
Ejemplo:
Este script utiliza el proceso familiar de dos pasos: primero transcribiendo el audio con Whisper, luego analizando el texto con GPT-4o usando un prompt específicamente diseñado para identificar y estructurar elementos de acción.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/meeting_tasks.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:39 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-24 10:29:00 CDT" # Updated time
current_location = "Plano, Texas, United States"
print(f"Running GPT-4o action item extraction from speech example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_tasks.mp3' with the actual filename.
audio_file_path = "meeting_tasks.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before extraction.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Extract Action Items from Text using GPT-4o ---
def extract_action_items(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for action item extraction."""
print("\nStep 2: Extracting action items...")
if not text_to_analyze:
print("Error: No text provided for extraction.")
return None
# Prompt designed specifically for extracting structured action items
system_prompt = "You are an expert meeting analyst focused on identifying actionable tasks."
user_prompt = f"""Analyze the following meeting or discussion transcription. Identify and extract all specific action items mentioned.
For each action item, provide:
- A clear description of the task.
- The person assigned (if mentioned, otherwise state 'Unassigned' or 'Group').
- Any deadline mentioned (if mentioned, otherwise state 'No deadline mentioned').
Distinguish between definite commitments/tasks and mere suggestions or hypothetical possibilities. Only list items that sound like actual tasks or commitments.
Format the output as a numbered list.
Transcription Text:
---
{text_to_analyze}
---
Extracted Action Items:
"""
try:
print("Sending text to GPT-4o for action item extraction...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong analytical capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=500, # Adjust based on expected number of action items
temperature=0.1 # Very low temperature for factual extraction
)
extracted_actions = response.choices[0].message.content
print("Action item extraction successful.")
return extracted_actions.strip()
except OpenAIError as e:
print(f"OpenAI API Error during extraction: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during extraction: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Extract Action Items
action_items_list = extract_action_items(
client,
full_transcription
)
if action_items_list:
print("\n--- Extracted Action Items ---")
print(action_items_list)
print("------------------------------")
print("\nThis demonstrates GPT-4o identifying and structuring actionable tasks from the discussion.")
else:
print("\nFailed to extract action items.")
else:
print("\nTranscription failed, cannot proceed to action item extraction.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para extraer elementos de acción del contenido hablado. Después de transcribir el audio con Whisper, GPT-4o analiza el texto para identificar tareas específicas, asignaciones y fechas límite discutidas.
- Proceso en dos pasos: Utiliza el flujo de trabajo estándar:
- Paso 1 (Whisper): Transcribe el audio de la reunión/discusión (
client.audio.transcriptions.create) a texto. La nota sobre el manejo de archivos de audio > 25MB mediante segmentación/concatenación sigue siendo crítica para uso real. - Paso 2 (GPT-4o): Analiza la transcripción completa usando
client.chat.completions.createcon un prompt adaptado para la extracción de tareas.
- Paso 1 (Whisper): Transcribe el audio de la reunión/discusión (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio de una reunión donde se asignaron tareas (meeting_tasks.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1. - Función de extracción de elementos de acción (
extract_action_items):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de prompts para tareas: Este es el núcleo. El prompt instruye explícitamente a GPT-4o para identificar elementos de acción, distinguirlos de meras sugerencias, y extraer la descripción de la tarea, la persona asignada (si se menciona), y la fecha límite (si se menciona). Solicita un formato de lista numerada estructurada. Se recomienda una
temperaturemuy baja (por ejemplo, 0.1) para mantener la salida enfocada en la extracción factual. - Utiliza
gpt-4opor su capacidad para entender el contexto conversacional e identificar compromisos.
- Salida: La función devuelve una cadena de texto que contiene la lista estructurada de elementos de acción extraídos.
- Ejecución principal: El script transcribe el audio, pasa el texto a la función de extracción e imprime la lista resultante de tareas.
- Relevancia del caso de uso: Esto aborda directamente la capacidad de "Extracción de elementos de acción". Muestra cómo la IA puede convertir automáticamente discusiones verbales no estructuradas en listas de tareas organizadas y ejecutables. Esto aumenta significativamente la productividad al garantizar el seguimiento, clarificar responsabilidades y reducir el esfuerzo manual de rastrear compromisos hechos durante las reuniones. Destaca la capacidad de GPT-4o para analizar conversaciones complejas e identificar asignaciones de tareas tanto explícitas como implícitas.
Preguntas y respuestas sobre el audio
Ejemplo de prompt: "¿Qué dijo el orador sobre el presupuesto?"
Las capacidades avanzadas de consulta de GPT-4o permiten conversaciones naturales sobre contenido de audio, permitiendo a los usuarios hacer preguntas específicas y recibir respuestas contextualmente relevantes. El modelo puede:
- Extraer información precisa de segmentos específicos
- Comprender el contexto y las referencias a lo largo de todo el audio
- Manejar preguntas de seguimiento sobre temas previamente discutidos
- Proporcionar referencias con marca de tiempo a las partes relevantes
- Hacer referencias cruzadas de información de múltiples partes de la grabación
Esta funcionalidad transforma la forma en que interactuamos con el contenido de audio, haciéndolo tan buscable y consultable como los documentos de texto. En lugar de revisar manualmente las grabaciones, los usuarios pueden simplemente hacer preguntas en lenguaje natural y recibir respuestas precisas y concisas. El sistema es particularmente valioso para:
- Participantes de reuniones que necesitan verificar detalles específicos
- Investigadores analizando grabaciones de entrevistas
- Estudiantes revisando contenido de conferencias
- Profesionales verificando conversaciones con clientes
- Equipos que buscan entender discusiones históricas
Ejemplo:
Este script primero transcribe un archivo de audio usando Whisper y luego utiliza GPT-4o para responder una pregunta específica realizada por el usuario sobre el contenido de esa transcripción.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/meeting_for_qa.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:47 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-01-11 11:47:00 CDT" # Updated time
current_location = "Orlando, Florida, United States"
print(f"Running GPT-4o Q&A about audio example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_for_qa.mp3' with the actual filename.
audio_file_path = "meeting_for_qa.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before Q&A.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Answer Question Based on Text using GPT-4o ---
def answer_question_about_text(client, full_text, question):
"""Sends transcribed text and a question to GPT-4o to get an answer."""
print(f"\nStep 2: Answering question about the transcription...")
print(f"Question: \"{question}\"")
if not full_text:
print("Error: No transcription text provided to answer questions about.")
return None
if not question:
print("Error: No question provided.")
return None
# Prompt designed specifically for answering questions based on provided text
system_prompt = "You are an AI assistant specialized in answering questions based *only* on the provided text transcription. Do not use outside knowledge."
user_prompt = f"""Based *solely* on the following transcription text, please answer the question below. If the answer is not found in the text, state that clearly.
Transcription Text:
---
{full_text}
---
Question: {question}
Answer:
"""
try:
print("Sending transcription and question to GPT-4o...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong comprehension and answering
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=300, # Adjust based on expected answer length
temperature=0.1 # Low temperature for factual answers based on text
)
answer = response.choices[0].message.content
print("Answer generation successful.")
return answer.strip()
except OpenAIError as e:
print(f"OpenAI API Error during Q&A: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during Q&A: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
transcription = transcribe_speech(client, audio_file_path)
if transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(transcription[:1000] + "..." if len(transcription) > 1000 else transcription)
print("------------------------------------")
# --- Ask Questions about the Transcription ---
# Define the question(s) you want to ask
user_question = "What was decided about the email marketing CTA button?"
# user_question = "Who is responsible for the A/B test on Platform B?"
# user_question = "What was the engagement increase on Platform A?"
print(f"\n--- Answering Question ---")
# Step 2: Get the answer from GPT-4o
answer = answer_question_about_text(
client,
transcription,
user_question
)
if answer:
print(f"\nAnswer to '{user_question}':")
print(answer)
print("------------------------------")
print("\nThis demonstrates GPT-4o answering specific questions based on the transcribed audio content.")
else:
print(f"\nFailed to get an answer for the question: '{user_question}'")
else:
print("\nTranscription failed, cannot proceed to Q&A.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para funcionar como un sistema de preguntas y respuestas para contenido de audio. Después de transcribir el habla con Whisper, los usuarios pueden hacer preguntas específicas en lenguaje natural, y GPT-4o proporcionará respuestas basadas en la información contenida en la transcripción.
- Proceso en dos pasos: El flujo de trabajo incluye:
- Paso 1 (Whisper): Transcribir el archivo de audio relevante (o texto concatenado de fragmentos de un archivo más largo) usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): Enviar la transcripción completa junto con la pregunta específica del usuario a
client.chat.completions.create.
- Paso 1 (Whisper): Transcribir el archivo de audio relevante (o texto concatenado de fragmentos de un archivo más largo) usando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que contenga la discusión o información sobre la que el usuario podría hacer preguntas (meeting_for_qa.mp3). La nota crítica sobre el manejo de audio >25MB mediante fragmentación/concatenación antes del paso de preguntas y respuestas sigue siendo esencial. - Función de transcripción (
transcribe_speech): Maneja el Paso 1. - Función de preguntas y respuestas (
answer_question_about_text):- Maneja el Paso 2, tomando tanto la transcripción
full_textcomo laquestioncomo entrada. - Ingeniería de prompt para preguntas y respuestas: El prompt es crucial. Instruye a GPT-4o para que actúe como un asistente especializado que responde preguntas basándose únicamente en el texto de transcripción proporcionado, indicándole explícitamente que no use conocimiento externo y que indique si la respuesta no se encuentra en el texto. Este fundamento es importante para la precisión. Una
temperaturebaja (por ejemplo, 0.1) ayuda a garantizar respuestas factuales derivadas directamente del texto fuente. - Utiliza
gpt-4opor su excelente comprensión lectora y capacidades de preguntas y respuestas.
- Maneja el Paso 2, tomando tanto la transcripción
- Salida: La función devuelve la respuesta de GPT-4o a la pregunta específica realizada.
- Ejecución principal: El script transcribe el audio, define una
user_questionde ejemplo, pasa la transcripción y la pregunta a la función de preguntas y respuestas, e imprime la respuesta resultante. - Relevancia de caso de uso: Esto aborda directamente la capacidad de "Preguntas y respuestas sobre el audio". Transforma las grabaciones de audio de archivos pasivos a fuentes de conocimiento interactivas. Los usuarios pueden encontrar rápidamente detalles específicos, verificar hechos o entender partes de una discusión sin buscar manualmente en el audio, haciéndolo invaluable para revisar reuniones, conferencias, entrevistas o cualquier conversación grabada.
Recuerde usar un archivo de audio que contenga información relevante para las posibles preguntas de prueba (puede usar el audio de muestra proporcionado). Modifique la variable user_question para probar diferentes consultas contra el contenido transcrito.
Destacar momentos clave
Ejemplo de prompt: "Identifique las declaraciones más importantes realizadas en este audio."
GPT-4o sobresale en identificar y extraer momentos cruciales del contenido de audio a través de sus capacidades avanzadas de comprensión del lenguaje natural. El modelo puede:
- Identificar decisiones clave y elementos de acción
- Extraer citas y declaraciones importantes
- Resaltar discusiones estratégicas y conclusiones
- Señalar transiciones críticas en conversaciones
Esta función es particularmente valiosa para:
- Participantes de reuniones que necesitan revisar rápidamente puntos importantes
- Ejecutivos que examinan grabaciones largas en busca de puntos de decisión
- Equipos que rastrean hitos de proyectos discutidos en llamadas
- Investigadores que identifican momentos significativos en entrevistas
El modelo proporciona marcas de tiempo y resúmenes contextuales para cada momento destacado, facilitando la navegación directa a las partes más relevantes de la grabación sin revisar todo el archivo de audio.
Ejemplo:
Este script sigue el patrón establecido de dos pasos: transcribir el audio con Whisper y luego analizar el texto con GPT-4o usando un prompt diseñado para identificar declaraciones significativas, decisiones o conclusiones.
Descargue el audio de ejemplo: https://files.cuantum.tech/audio/key_discussion.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:52 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-02-14 15:52:00 CDT" # Updated time
current_location = "Tampa, Florida, United States"
print(f"Running GPT-4o key moment highlighting example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'key_discussion.mp3' with the actual filename.
audio_file_path = "key_discussion.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before highlighting.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Highlight Key Moments from Text using GPT-4o ---
def highlight_key_moments(client, text_to_analyze):
"""Sends transcribed text to GPT-4o to identify and extract key moments."""
print("\nStep 2: Identifying key moments from transcription...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed specifically for identifying key moments/statements
system_prompt = "You are an expert analyst skilled at identifying the most significant parts of a discussion or presentation."
user_prompt = f"""Analyze the following transcription text. Identify and extract the key moments, which could include:
- Important decisions made
- Critical conclusions reached
- Significant statements or impactful quotes
- Major topic shifts or transitions
- Key questions asked or answered
For each key moment identified, provide the relevant quote or a concise summary of the moment. Present the output as a list.
Transcription Text:
---
{text_to_analyze}
---
Key Moments:
"""
try:
print("Sending text to GPT-4o for key moment identification...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong comprehension
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=700, # Adjust based on expected number/length of key moments
temperature=0.3 # Lean towards factual identification
)
key_moments = response.choices[0].message.content
print("Key moment identification successful.")
return key_moments.strip()
except OpenAIError as e:
print(f"OpenAI API Error during highlighting: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during highlighting: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Highlight Key Moments
highlights = highlight_key_moments(
client,
full_transcription
)
if highlights:
print("\n--- Identified Key Moments ---")
print(highlights)
print("----------------------------")
print("\nThis demonstrates GPT-4o extracting significant parts from the discussion.")
print("\nNote: Adding precise timestamps to these moments requires further processing using Whisper's 'verbose_json' output and correlating the text.")
else:
print("\nFailed to identify key moments.")
else:
print("\nTranscription failed, cannot proceed to highlight key moments.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para Resaltar Momentos Clave del contenido hablado. Después de la transcripción mediante Whisper, GPT-4o analiza el texto para identificar y extraer las partes más significativas, como decisiones cruciales, declaraciones importantes o cambios importantes de tema.
- Proceso en dos pasos:
- Paso 1 (Whisper): Transcribir el audio (
client.audio.transcriptions.create) para obtener el texto completo. Se reitera la necesidad de segmentar/concatenar para archivos de audio > 25MB. - Paso 2 (GPT-4o): Analizar la transcripción completa usando
client.chat.completions.createcon un prompt específicamente diseñado para momentos clave.
- Paso 1 (Whisper): Transcribir el audio (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que contenga una discusión o presentación donde ocurran momentos significativos (key_discussion.mp3). - Función de Transcripción (
transcribe_speech): Maneja el Paso 1. - Función de Resaltado (
highlight_key_moments):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de Prompt para Resaltados: El prompt instruye a GPT-4o a actuar como analista e identificar varios tipos de momentos clave (decisiones, conclusiones, citas impactantes, transiciones). Solicita la cita relevante o un resumen conciso para cada momento identificado, formateado como lista.
- Utiliza
gpt-4opor su capacidad para discernir importancia y contexto dentro del texto.
- Salida: La función devuelve una cadena de texto que contiene la lista de momentos clave identificados.
- Nota sobre Marcas de Tiempo: La explicación y salida del código mencionan explícitamente que mientras este proceso identifica el texto de los momentos clave, agregar marcas de tiempo precisas requeriría pasos adicionales. Esto implica usar el formato
verbose_jsonde Whisper (que incluye marcas de tiempo por segmento) y luego correlacionar el texto identificado por GPT-4o con esos segmentos cronometrados específicos – una tarea más compleja no cubierta en este ejemplo básico. - Ejecución Principal: El script transcribe el audio, pasa el texto a la función de resaltado e imprime la lista resultante de momentos clave.
- Relevancia de Caso de Uso: Esto aborda la capacidad de "Resaltar Momentos Clave" al mostrar cómo la IA puede examinar rápidamente grabaciones potencialmente largas para destacar las partes más críticas. Esto es altamente valioso para la revisión eficiente de reuniones, entrevistas o conferencias, permitiendo a los usuarios enfocarse en lo más importante sin escuchar todo el audio.
Para propósitos de prueba, use un archivo de audio que contenga una discusión relevante con segmentos clave claros e identificables (puede usar el archivo de audio de muestra proporcionado).
2.3.3 Casos de Uso del Mundo Real
El panorama empresarial moderno depende cada vez más de la comunicación por audio en varios sectores, desde ventas y servicio al cliente hasta educación y desarrollo personal. Comprender y utilizar eficazmente estas interacciones de audio se ha vuelto crucial para las organizaciones que buscan mejorar sus operaciones, fortalecer las relaciones con los clientes e impulsar mejores resultados. Esta sección explora varias aplicaciones clave donde el procesamiento y análisis avanzado de audio puede crear un valor significativo, demostrando cómo las herramientas potenciadas por IA pueden transformar datos de audio sin procesar en información procesable.
Desde el análisis de conversaciones de ventas hasta la mejora de experiencias educativas, estos casos de uso muestran la versatilidad y el poder de las tecnologías de comprensión de audio para abordar desafíos del mundo real. Cada aplicación representa una oportunidad única para aprovechar los datos de voz para mejorar la toma de decisiones, optimizar procesos y mejorar las experiencias de usuario.
1. Potenciación de Ventas
El análisis avanzado de grabaciones de llamadas de ventas proporciona un conjunto completo de herramientas para que los equipos de ventas optimicen su rendimiento. El sistema puede identificar objeciones clave planteadas por los prospectos, permitiendo a los equipos desarrollar mejores contraargumentos y preparar respuestas por adelantado. Rastrea técnicas de cierre exitosas analizando patrones en acuerdos exitosos, revelando qué enfoques funcionan mejor para diferentes segmentos de clientes y situaciones.
El sistema también mide métricas cruciales como tasas de conversión, duración de llamadas, proporción de habla-escucha y uso de frases clave. Estos datos ayudan a los equipos de ventas a entender qué comportamientos se correlacionan con resultados exitosos. Al analizar las respuestas de los clientes y patrones de reacción, los equipos pueden refinar el momento de sus presentaciones, mejorar sus técnicas de preguntas y comprender mejor las señales de compra.
Esta tecnología también permite a los gerentes de ventas documentar y compartir enfoques efectivos en todo el equipo, creando una base de conocimientos de mejores prácticas para desafíos comunes. Este conocimiento institucional puede ser particularmente valioso para la incorporación de nuevos miembros del equipo y mantener la excelencia consistente en ventas en toda la organización.
2. Inteligencia de Reuniones
El análisis integral de reuniones transforma la manera en que las organizaciones capturan y utilizan el contenido de las reuniones. El sistema va más allá de la transcripción básica al:
- Identificar y categorizar puntos clave de discusión para fácil referencia
- Detectar y extraer automáticamente elementos de acción de las conversaciones
- Asignar responsabilidades a miembros específicos del equipo basado en compromisos verbales
- Crear líneas de tiempo estructuradas y rastrear plazos mencionados durante las reuniones
- Generar listas automatizadas de tareas con clara propiedad y fechas de vencimiento
- Resaltar puntos de decisión y resultados de reuniones
- Proporcionar archivos de reuniones con capacidad de búsqueda para referencia futura
El sistema emplea procesamiento avanzado de lenguaje natural para comprender contexto, relaciones y compromisos expresados durante las conversaciones. Esto permite la creación y asignación automática de tareas, asegurando que nada se pierda. La integración con herramientas de gestión de proyectos permite la automatización fluida del flujo de trabajo, mientras que los recordatorios inteligentes ayudan a mantener a los miembros del equipo responsables de sus compromisos.
3. Soporte al Cliente
El análisis profundo de interacciones de servicio al cliente proporciona información integral sobre la experiencia del cliente y el rendimiento del equipo de soporte. El sistema puede:
- Evaluar el sentimiento del cliente en tiempo real analizando tono, elección de palabras y flujo de conversación
- Categorizar y priorizar automáticamente problemas urgentes basado en detección de palabras clave y análisis de contexto
- Generar métricas detalladas de satisfacción a través del análisis de conversaciones y retroalimentación del cliente
- Rastrear indicadores clave de rendimiento como tiempo de primera respuesta y tiempo de resolución
- Identificar puntos de dolor comunes y problemas recurrentes a través de múltiples interacciones
- Monitorear el rendimiento del agente de soporte y la consistencia en la entrega del servicio
Esto permite a los equipos de soporte mejorar los tiempos de respuesta, identificar problemas tendencia y mantener una calidad de servicio consistente en todas las interacciones. El sistema también puede proporcionar sugerencias automáticas de entrenamiento para agentes de soporte y generar información para la mejora del producto basada en patrones de retroalimentación del cliente.
4. Diario Personal
Transforma las notas de voz en reflexiones estructuradas con análisis de contexto emocional. Utilizando procesamiento avanzado de lenguaje natural, el sistema analiza las grabaciones de voz para detectar estados emocionales, niveles de estrés y sentimiento general a través del tono de voz, elección de palabras y patrones de habla. Esto crea una entrada de diario multidimensional y rica que captura no solo lo que se dijo, sino cómo se expresó.
Las capacidades de seguimiento del estado de ánimo del sistema van más allá de simples clasificaciones positivas/negativas, identificando estados emocionales con matices como entusiasmo, incertidumbre, confianza o preocupación. Al analizar estos patrones a lo largo del tiempo, los usuarios pueden obtener información valiosa sobre su bienestar emocional e identificar desencadenantes o patrones que afectan su estado mental.
Para el seguimiento de objetivos personales, el sistema puede categorizar y etiquetar automáticamente menciones de objetivos, actualizaciones de progreso y contratiempos. Puede generar informes de progreso que muestran el impulso hacia objetivos específicos, destacar obstáculos comunes e incluso sugerir posibles soluciones basadas en estrategias exitosas anteriores. El análisis de tendencias conductuales examina patrones en la toma de decisiones, formación de hábitos y crecimiento personal, proporcionando a los usuarios información práctica para la superación personal.
5. Educación y Práctica de Idiomas
El apoyo integral al aprendizaje de idiomas revoluciona la forma en que los estudiantes practican y mejoran sus habilidades lingüísticas. El sistema proporciona varios beneficios clave:
- Análisis del Habla: Los algoritmos avanzados analizan patrones de pronunciación, detectando variaciones sutiles en fonemas, patrones de acentuación y entonación. Esto ayuda a los estudiantes a entender exactamente dónde su pronunciación difiere de los hablantes nativos.
- Detección de Errores: El sistema identifica no solo errores de pronunciación, sino también errores gramaticales, uso incorrecto de palabras y problemas sintácticos en tiempo real. Esta retroalimentación inmediata ayuda a prevenir la formación de malos hábitos.
- Retroalimentación Personalizada: En lugar de correcciones genéricas, el sistema proporciona retroalimentación contextual que considera el nivel de competencia del estudiante, su idioma nativo y patrones de interferencia comunes específicos de su origen lingüístico.
- Seguimiento del Progreso: Métricas sofisticadas rastrean varios aspectos del desarrollo del lenguaje, incluyendo rango de vocabulario, fluidez al hablar, precisión gramatical y mejora en la pronunciación a lo largo del tiempo. Los informes visuales de progreso ayudan a motivar a los estudiantes e identificar áreas que necesitan atención.
- Aprendizaje Adaptativo: Basado en el análisis de rendimiento, el sistema crea planes de ejercicios personalizados dirigidos a debilidades específicas. Estos pueden incluir ejercicios focalizados de pronunciación, ejercicios gramaticales o actividades de construcción de vocabulario adaptadas a las necesidades del estudiante.
El sistema puede rastrear la mejora a lo largo del tiempo y sugerir ejercicios específicos para las áreas que necesitan mejora, creando un entorno de aprendizaje dinámico y receptivo que se adapta al progreso de cada estudiante.
2.3.4 Consideraciones de Privacidad
La privacidad es primordial al manejar grabaciones de audio. En primer lugar, obtener el consentimiento antes de analizar grabaciones de voz de terceros es un requisito legal y ético crucial. Es esencial asegurar el permiso escrito o documentado de todos los participantes antes de procesar cualquier grabación de voz, ya sean de reuniones, entrevistas, llamadas u otro contenido de audio que involucre a terceros. Las organizaciones deben implementar un proceso formal de consentimiento que describa claramente cómo se utilizará y analizará el audio.
Se deben implementar medidas de seguridad a lo largo del flujo de trabajo de procesamiento. Después de completar el análisis, es crítico usar openai.files.delete(file_id) para eliminar los archivos de audio de los servidores de OpenAI. Esta práctica minimiza la exposición de datos y ayuda a prevenir el acceso no autorizado y posibles violaciones de datos. Las organizaciones deben establecer procedimientos automatizados de limpieza para asegurar la eliminación consistente de archivos procesados.
El almacenamiento a largo plazo de datos de voz requiere consideración especial. Nunca almacene grabaciones de voz sensibles sin la aprobación explícita de todas las partes involucradas. Las organizaciones deben implementar políticas estrictas de manejo de datos que especifiquen claramente la duración del almacenamiento, medidas de seguridad y uso previsto. Se debe tener especial cuidado con las grabaciones que contengan información personal, secretos comerciales o discusiones confidenciales. Las mejores prácticas incluyen implementar encriptación para archivos de audio almacenados y mantener registros detallados de acceso.
2.3 Comprensión del Habla en GPT-4o
En esta sección, descubrirás cómo trabajar con capacidades avanzadas de procesamiento de audio que van más allá de la transcripción básica. GPT-4o introduce un enfoque revolucionario para la comprensión del audio al permitir la integración directa de archivos de audio junto con indicaciones textuales. Esto crea un sistema de interacción multimodal fluido donde tanto las entradas de audio como de texto se procesan simultáneamente. El sistema puede analizar varios aspectos del habla, incluyendo el tono, el contexto y el significado semántico, permitiéndote construir asistentes inteligentes sofisticados que pueden escuchar, comprender y responder naturalmente dentro de cualquier contexto dado.
La tecnología representa un avance significativo en el procesamiento de audio al combinar la transcripción estilo Whisper con las capacidades avanzadas de razonamiento de GPT-4o. Mientras que Whisper sobresale en la conversión del habla a texto, GPT-4o va más allá al realizar un análisis profundo del contenido transcrito. Esta integración ocurre en una interacción fluida, eliminando la necesidad de pasos de procesamiento separados. Por ejemplo, al procesar la grabación de una reunión de negocios, GPT-4o puede simultáneamente transcribir el habla, identificar hablantes, extraer elementos de acción y generar resúmenes, todo mientras mantiene el contexto y comprende los matices sutiles en la comunicación.
Esta poderosa combinación abre posibilidades sin precedentes para crear aplicaciones de IA más intuitivas y receptivas. Estas aplicaciones no solo pueden procesar y comprender el lenguaje hablado, sino que también pueden interpretar el contexto, la emoción y la intención de formas que anteriormente no eran posibles. Ya sea analizando llamadas de servicio al cliente, procesando conferencias educativas o facilitando la comunicación multilingüe, el sistema proporciona una comprensión integral del contenido hablado que va mucho más allá de la simple transcripción.
2.3.1 ¿Por qué GPT-4o para el Habla?
Mientras que la API de Whisper sobresale en convertir el lenguaje hablado en texto escrito, GPT-4o representa un salto revolucionario en las capacidades de procesamiento de audio. Para entender la distinción, imagina a Whisper como un transcriptor altamente capacitado que puede escribir con precisión cada palabra hablada, mientras que GPT-4o funciona más como un analista experimentado con una profunda comprensión contextual.
Las capacidades de GPT-4o se extienden mucho más allá de la transcripción básica. Puede comprender y procesar el habla en múltiples niveles simultáneamente:
Comprensión Semántica
Comprende el significado real detrás de las palabras, yendo más allá de la traducción palabra por palabra. Esta capacidad avanzada permite a GPT-4o procesar el lenguaje en múltiples niveles simultáneamente, entendiendo no solo el significado literal sino también las capas semánticas más profundas, el contexto cultural y el mensaje pretendido. Esto incluye la comprensión de modismos, metáforas, referencias culturales y expresiones regionales dentro del habla, así como la detección de matices sutiles en la comunicación que podrían perderse en una simple transcripción.
Por ejemplo, cuando alguien dice "está lloviendo a cántaros", GPT-4o entiende que significa una lluvia intensa en lugar de interpretar literalmente que caen cántaros del cielo. De manera similar, al procesar frases como "mucha mierda" antes de una actuación o "pan comido" para describir una tarea fácil, el sistema interpreta correctamente estas expresiones idiomáticas dentro de su contexto cultural.
También puede captar conceptos complejos como el sarcasmo ("Oh, genial, otra reunión"), el humor ("¿Por qué cruzó el modelo GPT la calle?"), y preguntas retóricas ("¿Quién no querría eso?"), haciéndolo capaz de comprender verdaderamente la comunicación humana en todo su contexto. Esta comprensión sofisticada se extiende a referencias culturales específicas, jerga profesional e incluso variaciones dialectales regionales, asegurando una interpretación precisa independientemente del origen o estilo de comunicación del hablante.
Ejemplo:
Dado que la interacción estándar de la API de OpenAI para esto típicamente involucra primero convertir el habla a texto (usando Whisper) y después analizar ese texto para un significado más profundo (usando GPT-4o), el ejemplo de código demostrará este proceso de dos pasos.
Este script:
- Transcribirá un archivo de audio que contiene lenguaje potencialmente matizado usando Whisper.
- Enviará el texto transcrito a GPT-4o con una indicación solicitando interpretación semántica.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/idiom_speech.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:37 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-04-21 19:37:00 CDT"
current_location = "Dallas, Texas, United States"
print(f"Running GPT-4o semantic speech understanding example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with nuanced speech
# IMPORTANT: Replace 'idiom_speech.mp3' with the actual filename.
# Good examples for audio content: "Wow, that presentation just knocked my socks off!",
# "Sure, I'd LOVE to attend another three-hour meeting.", "He really spilled the beans."
audio_file_path = "idiom_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Text for Semantic Meaning using GPT-4o ---
def analyze_text_meaning(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for semantic analysis."""
print(f"\nStep 2: Analyzing text for semantic meaning: \"{text_to_analyze}\"")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Construct prompt to ask for deeper meaning
system_prompt = "You are an expert in linguistics and communication."
user_prompt = (
f"Analyze the following phrase or sentence:\n\n'{text_to_analyze}'\n\n"
"Explain its likely intended meaning, considering context, idioms, "
"metaphors, sarcasm, humor, cultural references, or other nuances. "
"Go beyond a literal, word-for-word interpretation."
)
try:
print("Sending text to GPT-4o for analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for its strong understanding capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=250, # Adjust as needed
temperature=0.5 # Lower temperature for more focused analysis
)
analysis = response.choices[0].message.content
print("Semantic analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\nTranscription Result: {transcribed_text}")
# Step 2: Analyze the transcription for meaning
semantic_analysis = analyze_text_meaning(client, transcribed_text)
if semantic_analysis:
print("\n--- Semantic Analysis Result ---")
print(semantic_analysis)
print("--------------------------------\n")
print("This demonstrates GPT-4o understanding nuances beyond literal text.")
else:
print("\nSemantic analysis failed.")
else:
print("\nTranscription failed, cannot proceed to analysis.")Desglose del código:
- Contexto: Este código demuestra la comprensión semántica avanzada del habla de GPT-4o. Va más allá de la simple transcripción al interpretar el significado, incluyendo matices como modismos, sarcasmo o frases dependientes del contexto.
- Proceso en dos pasos: El ejemplo utiliza un enfoque estándar de API en dos etapas:
- Paso 1 (Whisper): El archivo de audio se convierte primero en texto utilizando la API de Whisper (
client.audio.transcriptions.create). Esto captura las palabras habladas con precisión. - Paso 2 (GPT-4o): El texto transcrito se envía luego al modelo GPT-4o (
client.chat.completions.create) con una instrucción específica solicitando el análisis del significado detrás de las palabras, considerando interpretaciones no literales.
- Paso 1 (Whisper): El archivo de audio se convierte primero en texto utilizando la API de Whisper (
- Requisitos previos: Requiere la configuración estándar de
openaiypython-dotenv, clave API y, fundamentalmente, un archivo de audio que contenga habla con ciertos matices (por ejemplo, que incluya un modismo como "poner las cartas sobre la mesa", un comentario sarcástico como "Qué bien, otra reunión", o una frase culturalmente específica). - Función de transcripción (
transcribe_speech): Esta función maneja el Paso 1, tomando la ruta del archivo de audio y devolviendo la transcripción en texto plano de Whisper. - Función de análisis semántico (
analyze_text_meaning):- Esta función maneja el Paso 2. Recibe el texto transcrito.
- Diseño de la instrucción: Construye una instrucción específicamente pidiendo a GPT-4o que actúe como experto lingüístico y explique el significado pretendido, considerando modismos, sarcasmo, contexto, etc., solicitando explícitamente un análisis más allá de la interpretación literal.
- Utiliza
gpt-4ocomo modelo por sus sólidas capacidades de razonamiento y comprensión. - Devuelve el análisis proporcionado por GPT-4o.
- Ejecución principal: El script primero transcribe el audio. Si tiene éxito, pasa el texto a la función de análisis. Finalmente, imprime tanto la transcripción literal como la interpretación semántica de GPT-4o.
- Relevancia del caso de uso: Este ejemplo muestra claramente cómo la combinación de Whisper y GPT-4o permite una comprensión más profunda del lenguaje hablado que la simple transcripción. Demuestra la capacidad descrita – comprender modismos ("llover a cántaros"), sarcasmo, humor y contexto – haciendo que la interacción con la IA esté más alineada con la comunicación humana.
Recuerda usar un archivo de audio que contenga lenguaje no literal para las pruebas para mostrar mejor el paso de análisis semántico. Reemplaza 'idiom_speech.mp3' con tu ruta de archivo real.
Análisis Contextual
Interpreta las declaraciones dentro de su contexto más amplio, teniendo en cuenta la información circundante, discusiones previas, referencias culturales y factores situacionales. Esto incluye entender cómo el tiempo, lugar, relaciones entre hablantes y conversaciones previas influyen en el significado. El análisis considera múltiples capas de contexto:
- Contexto temporal: Cuándo se dice algo (hora del día, día de la semana, temporada o período histórico)
- Contexto social: Las relaciones entre hablantes, dinámicas de poder y normas sociales
- Contexto físico: La ubicación y el entorno donde ocurre la comunicación
- Contexto cultural: Conocimientos, creencias y costumbres compartidas que influyen en la interpretación
Por ejemplo, la frase "se está haciendo tarde" podría significar diferentes cosas en diferentes contextos:
- Durante una reunión de trabajo: Una sugerencia cortés para concluir la discusión
- En una reunión social: Una indicación de que alguien necesita irse
- De un padre a un hijo: Un recordatorio sobre la hora de dormir
- En una discusión de proyecto: Preocupación por plazos que se aproximan
GPT-4o analiza estas pistas contextuales junto con factores adicionales como el tono de voz, patrones de habla e historial de conversación para proporcionar interpretaciones más precisas y matizadas de la comunicación hablada. Esta comprensión contextual profunda permite al sistema captar el verdadero significado pretendido detrás de las palabras, más allá de su interpretación literal.
Ejemplo:
Este caso de uso se centra en la capacidad de GPT-4o para interpretar el habla transcrita dentro de su contexto más amplio (temporal, social, físico, cultural). Como en el ejemplo de comprensión semántica, esto típicamente involucra un proceso de dos pasos: transcribir el habla con Whisper, luego analizar el texto con GPT-4o, pero esta vez proporcionando explícitamente información contextual a GPT-4o.
Este ejemplo de código:
- Transcribirá una frase simple dependiente del contexto desde un archivo de audio usando Whisper.
- Enviará el texto transcrito a GPT-4o múltiples veces, cada vez proporcionando un contexto diferente.
- Mostrará cómo la interpretación de GPT-4o de la misma frase cambia según el contexto proporcionado.
Descarga el audio de ejemplo: https://files.cuantum.tech/audio/context_phrase.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:44 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-02-11 11:44:00 CDT" # Updated time
current_location = "Miami, Florida, United States"
print(f"Running GPT-4o contextual speech analysis example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with the context-dependent phrase
# IMPORTANT: Replace 'context_phrase.mp3' with the actual filename.
# The audio content should ideally be just "It's getting late."
audio_file_path = "context_phrase.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from the previous example (gpt4o_speech_semantic_py)
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Text for Meaning WITHIN a Given Context using GPT-4o ---
def analyze_text_with_context(client, text_to_analyze, context_description):
"""Sends transcribed text and context description to GPT-4o for analysis."""
print(f"\nStep 2: Analyzing text \"{text_to_analyze}\" within context...")
print(f"Context Provided: {context_description}")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
if not context_description:
print("Error: Context description must be provided for this analysis.")
return None
# Construct prompt asking for interpretation based on context
system_prompt = "You are an expert in analyzing communication and understanding context."
user_prompt = (
f"Consider the phrase: '{text_to_analyze}'\n\n"
f"Now, consider the specific context in which it was said: '{context_description}'\n\n"
"Based *only* on this context, explain the likely intended meaning, implication, "
"or function of the phrase in this situation."
)
try:
print("Sending text and context to GPT-4o for analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong contextual reasoning
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=200, # Adjust as needed
temperature=0.3 # Lower temperature for more focused contextual interpretation
)
analysis = response.choices[0].message.content
print("Contextual analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio phrase
transcribed_phrase = transcribe_speech(client, audio_file_path)
if transcribed_phrase:
print(f"\nTranscription Result: \"{transcribed_phrase}\"")
# Define different contexts for the same phrase
contexts = [
"Said during a business meeting scheduled to end at 5:00 PM, spoken at 4:55 PM.",
"Said by a guest at a social party around 1:00 AM.",
"Said by a parent to a young child at 9:00 PM on a school night.",
"Said during a critical project discussion about an upcoming deadline, spoken late in the evening.",
"Said by someone looking out the window on a short winter afternoon."
]
print("\n--- Analyzing Phrase in Different Contexts ---")
# Step 2: Analyze the phrase within each context
for i, context in enumerate(contexts):
print(f"\n--- Analysis for Context {i+1} ---")
contextual_meaning = analyze_text_with_context(
client,
transcribed_phrase,
context
)
if contextual_meaning:
print(f"Meaning in Context: {contextual_meaning}")
else:
print("Contextual analysis failed for this context.")
print("------------------------------------")
print("\nThis demonstrates how GPT-4o interprets the same phrase differently based on provided context.")
else:
print("\nTranscription failed, cannot proceed to contextual analysis.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para el análisis contextual del habla. Muestra cómo la interpretación de una frase hablada puede cambiar drásticamente según la situación circundante (factores temporales, sociales y situacionales).
- Proceso de dos pasos con inyección de contexto:
- Paso 1 (Whisper): El archivo de audio que contiene una frase dependiente del contexto (por ejemplo, "Se está haciendo tarde") se transcribe a texto usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): El texto transcrito se envía entonces a GPT-4o (
client.chat.completions.create), pero de manera crucial, el prompt ahora incluye una descripción del contexto específico en el que se pronunció la frase.
- Paso 1 (Whisper): El archivo de audio que contiene una frase dependiente del contexto (por ejemplo, "Se está haciendo tarde") se transcribe a texto usando
- Requisitos previos: Requiere la configuración estándar de
openaiypython-dotenv, clave API, y un archivo de audio que contenga una frase simple cuyo significado dependa en gran medida del contexto (el ejemplo usa "Se está haciendo tarde"). - Función de transcripción (
transcribe_speech): Esta función (reutilizada del ejemplo anterior) maneja el Paso 1. - Función de análisis contextual (
analyze_text_with_context):- Esta función maneja el Paso 2 y ahora acepta un argumento adicional:
context_description. - Diseño del prompt: El prompt proporciona explícitamente tanto la frase transcrita como la
context_descriptiona GPT-4o, pidiéndole que interprete la frase dentro de esa situación específica. - Utiliza
gpt-4opor su capacidad de razonar basándose en el contexto proporcionado.
- Esta función maneja el Paso 2 y ahora acepta un argumento adicional:
- Demostración de la dependencia del contexto (Ejecución principal):
- El script primero transcribe la frase (por ejemplo, "Se está haciendo tarde").
- Luego define una lista de diferentes descripciones de contexto (finalización de reunión, fiesta nocturna, hora de dormir, fecha límite de proyecto, día corto de invierno).
- Llama a la función
analyze_text_with_contextrepetidamente, usando la misma frase transcrita pero proporcionando una descripción de contexto diferente cada vez. - Al imprimir el resultado del análisis para cada contexto, el script muestra claramente cómo la interpretación de GPT-4o cambia según el contexto proporcionado (por ejemplo, sugiriendo concluir vs. indicando cansancio vs. notando la disminución de la luz del día).
- Relevancia del caso de uso: Esto destaca la comprensión sofisticada de GPT-4o, yendo más allá de las palabras literales para captar el significado pretendido influenciado por factores temporales, sociales y situacionales. Esto es vital para aplicaciones que necesitan una interpretación precisa de la comunicación en el mundo real en negocios, interacciones sociales o cualquier entorno rico en contexto. Muestra cómo los desarrolladores pueden proporcionar contexto relevante junto con el texto transcrito para obtener interpretaciones más precisas y matizadas de la IA.
Para probar este código efectivamente, crea un archivo de audio que contenga solo la frase "Se está haciendo tarde" (u otra frase dependiente del contexto), o descarga el archivo de muestra proporcionado. Recuerda actualizar la ruta 'context_phrase.mp3' para que coincida con la ubicación de tu archivo.
Generación de resúmenes
Las capacidades de generación de resúmenes de GPT-4o representan un avance significativo en el análisis de contenido impulsado por IA. El sistema crea resúmenes concisos y significativos de discusiones complejas mediante la destilación inteligente de información clave de conversaciones, reuniones o presentaciones extensas. Utilizando procesamiento avanzado del lenguaje natural y comprensión contextual, GPT-4o puede identificar temas principales, puntos críticos y conclusiones esenciales mientras mantiene el significado central y el contexto de la discusión original.
El sistema emplea varias técnicas sofisticadas:
- Reconocimiento de patrones: Identifica temas recurrentes y puntos importantes de discusión a lo largo de conversaciones extensas
- Análisis contextual: Comprende el contexto más amplio y las relaciones entre diferentes partes de la discusión
- Detección de prioridades: Determina automáticamente qué información es más crucial para el resumen
- Comprensión semántica: Capta significados subyacentes e implicaciones más allá del contenido superficial
Los resúmenes generados pueden personalizarse para diferentes propósitos y audiencias:
- Informes ejecutivos: Enfocados en perspectivas estratégicas y decisiones de alto nivel
- Actas de reuniones: Documentación detallada de discusiones y elementos de acción
- Resúmenes rápidos: Aspectos destacados condensados para consumo rápido de información
- Resúmenes técnicos: Énfasis en detalles técnicos específicos y especificaciones
Lo que distingue a GPT-4o es su capacidad para preservar detalles importantes mientras reduce significativamente la sobrecarga de información, convirtiéndolo en una herramienta invaluable para la comunicación empresarial moderna y la gestión del conocimiento.
Ejemplo:
Este ejemplo se centra en la capacidad de GPT-4o para generar resúmenes concisos y significativos de contenido hablado potencialmente extenso obtenido a través de Whisper.
Esto involucra el proceso familiar de dos pasos: primero, transcribir el audio con Whisper para obtener el texto completo, y segundo, usar las capacidades de comprensión del lenguaje de GPT-4o para analizar y resumir ese texto según necesidades específicas. Este ejemplo demostrará la generación de diferentes tipos de resúmenes a partir de la misma transcripción.
Descarga el audio de muestra: https://files.cuantum.tech/audio/discussion_audio.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 7:59 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-04-10 15:59:00 CDT" # Updated time
current_location = "Houston, Texas, United States"
print(f"Running GPT-4o speech summarization example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'discussion_audio.mp3' with the actual filename.
audio_file_path = "discussion_audio.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before summarization.")
except OSError:
pass # Ignore size check error, proceed with transcription attempt
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Generate Summary from Text using GPT-4o ---
def summarize_text(client, text_to_summarize, summary_style="concise overview"):
"""Sends transcribed text to GPT-4o for summarization."""
print(f"\nStep 2: Generating '{summary_style}' summary...")
if not text_to_summarize:
print("Error: No text provided for summarization.")
return None
# Tailor the prompt based on the desired summary style
system_prompt = "You are an expert meeting summarizer and information distiller."
user_prompt = f"""Please generate a {summary_style} of the following discussion transcription.
Focus on accurately capturing the key information relevant to a {summary_style}. For example:
- For an 'executive briefing', focus on strategic points, decisions, and outcomes.
- For 'detailed meeting minutes', include main topics, key arguments, decisions, and action items.
- For a 'concise overview', provide the absolute main points and purpose.
- For a 'technical summary', emphasize technical details, specifications, or findings.
Transcription Text:
---
{text_to_summarize}
---
Generate the {summary_style}:
"""
try:
print(f"Sending text to GPT-4o for {summary_style}...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong summarization
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=400, # Adjust based on expected summary length
temperature=0.5 # Balance creativity and focus
)
summary = response.choices[0].message.content
print(f"'{summary_style}' generation successful.")
return summary.strip()
except OpenAIError as e:
print(f"OpenAI API Error during summarization: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during summarization: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("--------------------------")
# Step 2: Generate summaries in different styles
summary_styles_to_generate = [
"concise overview",
"detailed meeting minutes with action items",
"executive briefing focusing on decisions",
# "technical summary" # Add if relevant to your audio content
]
print("\n--- Generating Summaries ---")
for style in summary_styles_to_generate:
print(f"\n--- Summary Style: {style} ---")
summary_result = summarize_text(
client,
full_transcription,
summary_style=style
)
if summary_result:
print(summary_result)
else:
print(f"Failed to generate '{style}'.")
print("------------------------------------")
print("\nThis demonstrates GPT-4o generating different summaries from the same transcription based on the prompt.")
else:
print("\nTranscription failed, cannot proceed to summarization.")Desglose del código:
- Contexto: Este código demuestra la capacidad avanzada de GPT-4o para generar resúmenes de contenido hablado. Utiliza un proceso de dos pasos: transcribir el audio con Whisper y luego usar GPT-4o para destilar inteligentemente la información clave de la transcripción en un resumen conciso.
- Manejo de Audio Extenso (Nota Crucial): Los prerrequisitos y comentarios del código abordan explícitamente el límite de 25MB de la API de Whisper. Para reuniones o presentaciones largas del mundo real, el audio debe ser dividido en fragmentos, cada fragmento transcrito por separado, y los textos resultantes concatenados antes de ser enviados al paso de resumen. El ejemplo de código procesa un solo archivo de audio por simplicidad, pero destaca este flujo de trabajo esencial para contenido más largo.
- Prerrequisitos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que representa la discusión a resumir (discussion_audio.mp3). - Función de Transcripción (
transcribe_speech): Maneja el Paso 1, convirtiendo el audio de entrada (o fragmento de audio) en texto plano usando Whisper. - Función de Resumen (
summarize_text):- Maneja el Paso 2, tomando el texto transcrito completo como entrada.
- Resúmenes Personalizables: Acepta un argumento
summary_style(por ejemplo, "informe ejecutivo", "actas detalladas de reunión"). - Ingeniería de Prompt: El prompt enviado a GPT-4o se construye dinámicamente según el
summary_stylesolicitado. Instruye a GPT-4o para actuar como un experto en resúmenes y adaptar la salida (enfocándose en puntos estratégicos, elementos de acción, detalles técnicos, etc.) según el estilo deseado. - Utiliza
gpt-4opor sus avanzadas capacidades de comprensión y resumen.
- Demostración de Diferentes Tipos de Resumen (Ejecución Principal):
- El script primero obtiene la transcripción completa.
- Luego define una lista de diferentes
summary_styles_to_generate. - Llama a la función
summarize_textmúltiples veces, pasando la misma transcripción completa cada vez pero variando el argumentosummary_style. - Al imprimir cada resumen resultante, el script muestra claramente cómo GPT-4o adapta el nivel de detalle y enfoque según el prompt, generando salidas distintas (por ejemplo, una visión general breve vs. actas detalladas) del mismo texto fuente.
- Relevancia de Caso de Uso: Esto aborda directamente la capacidad de "Generación de Resúmenes". Muestra cómo la combinación de Whisper y GPT-4o puede transformar discusiones habladas extensas en varios formatos útiles (informes ejecutivos, actas de reuniones, resúmenes rápidos), ahorrando tiempo y mejorando la gestión del conocimiento en negocios, educación y creación de contenido.
Extracción de Puntos Clave
Identifica y destaca información crucial aprovechando las capacidades avanzadas de procesamiento del lenguaje natural de GPT-4o. A través de algoritmos sofisticados y comprensión contextual, el modelo analiza contenido hablado para extraer ideas significativas. El modelo puede:
- Extraer conceptos centrales y argumentos principales del contenido hablado - Esto implica identificar las ideas fundamentales, mensajes clave y evidencia de respaldo presentada en conversaciones, presentaciones o discusiones. El modelo distingue entre puntos primarios y secundarios, asegurando que se capture la información esencial.
- Identificar puntos de decisión críticos y elementos de acción - Al analizar el flujo de la conversación y el contexto, GPT-4o reconoce momentos cuando se toman decisiones, se establecen compromisos o se asignan tareas. Esto incluye detectar tanto asignaciones explícitas ("John se encargará de esto") como implícitas ("Deberíamos investigar esto más a fondo").
- Priorizar información basada en contexto y relevancia - El modelo evalúa la importancia de diferentes piezas de información dentro de su contexto específico, considerando factores como urgencia, impacto y relación con los objetivos generales. Esto ayuda a crear resúmenes jerárquicos que enfatizan lo más importante.
- Seguir temas clave y tópicos recurrentes a través de conversaciones - GPT-4o mantiene consciencia de patrones de discusión, identificando cuando ciertos temas resurgen y cómo evolucionan con el tiempo. Esta capacidad es particularmente valiosa para el monitoreo de proyectos a largo plazo o el seguimiento de preocupaciones continuas a través de múltiples reuniones.
Ejemplo:
Este ejemplo se centra en usar GPT-4o para extraer información específica y crucial—puntos clave, decisiones, elementos de acción—del habla transcrita, yendo más allá de un resumen general.
Esto nuevamente utiliza el enfoque de dos pasos: Whisper transcribe el audio, y luego GPT-4o analiza el texto basado en un prompt diseñado para extracción.
Descarga la muestra de audio: https://files.cuantum.tech/audio/meeting_for_extraction.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:07 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-21 22:07:00 CDT" # Updated time
current_location = "Austin, Texas, United States"
print(f"Running GPT-4o key point extraction from speech example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_for_extraction.mp3' with the actual filename.
audio_file_path = "meeting_for_extraction.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before extraction.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Extract Key Points, Decisions, Actions using GPT-4o ---
def extract_key_points(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for key point extraction."""
print("\nStep 2: Extracting key points, decisions, and actions...")
if not text_to_analyze:
print("Error: No text provided for extraction.")
return None
# Prompt designed specifically for extraction
system_prompt = "You are an expert meeting analyst. Your task is to carefully read the provided transcript and extract specific types of information."
user_prompt = f"""Analyze the following meeting or discussion transcription. Identify and extract the following information, presenting each under a clear heading:
1. **Key Points / Core Concepts:** List the main topics, arguments, or fundamental ideas discussed.
2. **Decisions Made:** List any clear decisions that were reached during the discussion.
3. **Action Items:** List specific tasks assigned to individuals or the group. If possible, note who is responsible and any mentioned deadlines.
If any category has no relevant items, state "None identified".
Transcription Text:
---
{text_to_analyze}
---
Extracted Information:
"""
try:
print("Sending text to GPT-4o for extraction...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong analytical capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=600, # Adjust based on expected length of extracted info
temperature=0.2 # Lower temperature for more factual extraction
)
extracted_info = response.choices[0].message.content
print("Extraction successful.")
return extracted_info.strip()
except OpenAIError as e:
print(f"OpenAI API Error during extraction: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during extraction: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Extract Key Information
extracted_details = extract_key_points(
client,
full_transcription
)
if extracted_details:
print("\n--- Extracted Key Information ---")
print(extracted_details)
print("---------------------------------")
print("\nThis demonstrates GPT-4o identifying and structuring key takeaways from the discussion.")
else:
print("\nFailed to extract key information.")
else:
print("\nTranscription failed, cannot proceed to key point extraction.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para extraer puntos clave del contenido hablado. Después de transcribir el audio usando Whisper, GPT-4o analiza el texto para identificar y aislar información crucial como conceptos fundamentales, decisiones tomadas y elementos de acción asignados.
- Proceso de dos pasos: Al igual que la sumarización, esto se basa en:
- Paso 1 (Whisper): Transcripción del audio (
client.audio.transcriptions.create) para obtener el texto completo. La nota crítica sobre el manejo de archivos de audio mayores a 25MB mediante segmentación y concatenación sigue siendo aplicable. - Paso 2 (GPT-4o): Análisis de la transcripción completa usando
client.chat.completions.createcon un prompt específicamente diseñado para la extracción.
- Paso 1 (Whisper): Transcripción del audio (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio de una reunión o discusión donde es probable que haya información clave (meeting_for_extraction.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo la transcripción en texto plano. - Función de extracción (
extract_key_points):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de prompt para extracción: Esto es clave. El prompt instruye explícitamente a GPT-4o a actuar como analista y extraer información bajo encabezados específicos: "Puntos Clave / Conceptos Fundamentales", "Decisiones Tomadas" y "Elementos de Acción". Esta solicitud estructurada guía a GPT-4o para identificar y categorizar la información relevante con precisión. Se sugiere una
temperaturemás baja (por ejemplo, 0.2) para fomentar una salida más factual y menos creativa, adecuada para la extracción. - Utiliza
gpt-4opor sus avanzadas capacidades analíticas.
- Salida: La función devuelve una cadena de texto que contiene la información extraída, estructurada idealmente bajo los encabezados solicitados.
- Ejecución principal: El script transcribe el audio, luego pasa el texto a la función de extracción, y finalmente imprime la salida estructurada.
- Relevancia del caso de uso: Esto aborda directamente la capacidad de "Extracción de Puntos Clave". Demuestra cómo la IA puede procesar automáticamente discusiones extensas para extraer los conceptos más importantes, rastrear decisiones y listar tareas accionables, ahorrando tiempo significativo en la revisión de grabaciones o generación de seguimientos de reuniones. Destaca la capacidad de GPT-4o para comprender el flujo conversacional e identificar momentos significativos (decisiones, asignaciones) dentro del texto.
Inteligencia Emocional
Detecta el tono, el sentimiento y los matices emocionales en la comunicación hablada a través de las capacidades avanzadas de procesamiento del lenguaje natural de GPT-4o. Este sofisticado sistema realiza un análisis profundo de los patrones del habla y elementos contextuales para comprender las capas emocionales de la comunicación. El modelo puede identificar señales emocionales sutiles como:
- Inflexiones y patrones de voz que indican emoción, duda o preocupación - Incluyendo variaciones de tono, cambios en el ritmo del habla y patrones de estrés vocal que los humanos utilizan naturalmente para transmitir emociones
- Cambios en el tempo y volumen del habla que sugieren estados emocionales - Por ejemplo, un habla rápida podría indicar emoción o ansiedad, mientras que un habla más lenta podría sugerir reflexión o incertidumbre
- Marcadores emocionales contextuales como risas, suspiros o pausas - El modelo reconoce sonidos no verbales y silencios que transmiten significado emocional importante en la conversación
- Matices culturales y situacionales que afectan la expresión emocional - Comprensión de cómo diferentes culturas expresan las emociones de manera diferente y cómo el contexto influye en la interpretación emocional
Esta conciencia emocional permite a GPT-4o proporcionar respuestas más matizadas y apropiadas al contexto, haciéndolo particularmente valioso para aplicaciones en servicio al cliente (donde entender la frustración o satisfacción del cliente es crucial), conversaciones terapéuticas (donde el apoyo emocional y la comprensión son primordiales), y coaching personal (donde la motivación y el crecimiento emocional son objetivos clave). La capacidad del sistema para detectar estas señales emocionales sutiles permite una comunicación más empática y efectiva en diversos contextos profesionales y personales.
Ejemplo:
Este ejemplo explora el uso de GPT-4o para "Inteligencia Emocional" – detectando tono, sentimiento y matices emocionales en el habla.
Es importante entender cómo funciona esto con las APIs estándar actuales de OpenAI. Mientras que GPT-4o sobresale en entender la emoción desde el texto, analizar directamente características de audio como tono, variación de tono, tempo, suspiros o risas como audio no es una función principal de la transcripción estándar de Whisper o del endpoint de Chat Completions API al procesar texto transcrito.
Por lo tanto, la forma más práctica de demostrar este concepto usando estas APIs es un proceso de dos pasos:
- Transcribir Voz a Texto: Usar Whisper para obtener las palabras habladas.
- Analizar Texto para Emociones: Usar GPT-4o para analizar el texto transcrito en busca de indicadores de emoción, sentimiento o tono basados en la elección de palabras, fraseo y contexto descrito en el texto.
Descarga el audio de muestra: https://files.cuantum.tech/audio/emotional_speech.mp3
Este ejemplo de código implementa este enfoque de análisis basado en texto de dos pasos.
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:13 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-21 20:13:00 CDT" # Updated time
current_location = "Atlanta, Georgia, United States"
print(f"Running GPT-4o speech emotion analysis (text-based) example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with potentially emotional speech
# IMPORTANT: Replace 'emotional_speech.mp3' with the actual filename.
audio_file_path = "emotional_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Transcribed Text for Emotion/Sentiment using GPT-4o ---
def analyze_text_emotion(client, text_to_analyze):
"""
Sends transcribed text to GPT-4o for emotion and sentiment analysis.
Note: This analyzes the text content, not acoustic features of the original audio.
"""
print("\nStep 2: Analyzing transcribed text for emotion/sentiment...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed for text-based emotion/sentiment analysis
system_prompt = "You are an expert in communication analysis, skilled at detecting sentiment, tone, and potential underlying emotions from text."
user_prompt = f"""Analyze the following text for emotional indicators:
Text:
---
{text_to_analyze}
---
Based *only* on the words, phrasing, and punctuation in the text provided:
1. What is the overall sentiment (e.g., Positive, Negative, Neutral, Mixed)?
2. What is the likely emotional tone (e.g., Frustrated, Excited, Calm, Anxious, Sarcastic, Happy, Sad)?
3. Are there specific words or phrases that indicate these emotions? Explain briefly.
Provide the analysis:
"""
try:
print("Sending text to GPT-4o for emotion analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for nuanced understanding
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=300, # Adjust as needed
temperature=0.4 # Slightly lower temp for more grounded analysis
)
analysis = response.choices[0].message.content
print("Emotion analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\n--- Transcription Result ---")
print(transcribed_text)
print("----------------------------")
# Step 2: Analyze the transcription for emotion/sentiment
emotion_analysis = analyze_text_emotion(
client,
transcribed_text
)
if emotion_analysis:
print("\n--- Emotion/Sentiment Analysis (from Text) ---")
print(emotion_analysis)
print("----------------------------------------------")
print("\nNote: This analysis is based on the transcribed text content. It does not directly analyze acoustic features like tone of voice from the original audio.")
else:
print("\nEmotion analysis failed.")
else:
print("\nTranscription failed, cannot proceed to emotion analysis.")
# --- End of Code Example ---
Desglose del código:
- Contexto: Este código demuestra cómo GPT-4o puede utilizarse para inferir el tono emocional y el sentimiento del lenguaje hablado. Utiliza un proceso de dos pasos común para este tipo de análisis con las APIs actuales.
- Proceso de dos pasos y limitación:
- Paso 1 (Whisper): Primero, el audio se transcribe a texto utilizando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): El texto resultante es entonces analizado por GPT-4o (
client.chat.completions.create) utilizando un prompt específicamente diseñado para identificar indicadores de sentimiento y emocionales dentro del texto. - Limitación importante: La explicación (y los comentarios del código) deben establecer claramente que este método analiza el contenido lingüístico (palabras, frases) proporcionado por Whisper. No analiza directamente características acústicas del audio original como el tono, tempo, o sonidos no verbales específicos (suspiros, risas) a menos que estos sean transcritos por Whisper (lo cual no suele ocurrir con señales sutiles). La verdadera detección acústica de emociones requeriría diferentes herramientas o APIs.
- Paso 1 (Whisper): Primero, el audio se transcribe a texto utilizando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio donde las palabras del hablante puedan sugerir una emoción (emotional_speech.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo texto plano. - Función de análisis emocional (
analyze_text_emotion):- Maneja el Paso 2, tomando el texto transcrito.
- Diseño del prompt: El prompt solicita explícitamente a GPT-4o que analice el texto proporcionado para determinar el sentimiento general (Positivo/Negativo/Neutral), el probable tono emocional (Frustrado, Emocionado, etc.), y evidencia textual de respaldo. Aclara que el análisis debe basarse únicamente en el texto.
- Utiliza
gpt-4opara su sofisticada comprensión del lenguaje.
- Resultado: La función devuelve el análisis textual de GPT-4o sobre la emoción y el sentimiento inferidos.
- Ejecución principal: El script transcribe el audio, pasa el texto para su análisis, imprime ambos resultados y reitera la limitación respecto a las características acústicas.
- Relevancia de caso de uso: Aunque no analiza la acústica directamente, este enfoque basado en texto sigue siendo valioso para aplicaciones como servicio al cliente (detectando frustración/satisfacción por la elección de palabras), analizando retroalimentación, u obteniendo una sensación general del sentimiento en interacciones habladas, complementando otras formas de análisis. Demuestra la capacidad de GPT-4o para interpretar lenguaje emocional.
Recuerda usar un archivo de audio donde las palabras habladas transmitan alguna emoción para que este ejemplo sea efectivo. Reemplaza 'emotional_speech.mp3' con tu ruta de archivo.
Comprensión implícita
GPT-4o demuestra capacidades notables en la comprensión de las capas más profundas de la comunicación humana, yendo mucho más allá del simple reconocimiento de palabras para captar los matices intrincados del habla. Las sofisticadas habilidades de comprensión del modelo incluyen:
- Detectar contexto y suposiciones subyacentes
- Comprende el conocimiento implícito compartido entre hablantes
- Reconoce hechos no declarados pero comúnmente aceptados dentro de dominios específicos
- Identifica premisas ocultas en conversaciones
- Comprender referencias culturales y expresiones idiomáticas
- Procesa dichos y coloquialismos específicos de cada región
- Reconoce metáforas y analogías específicas de cada cultura
- Adapta la comprensión basándose en el contexto cultural
- Interpretar recursos retóricos
Ejemplo:
Similar a los ejemplos anteriores que involucran comprensión más profunda (Semántica, Contextual, Emocional), esto típicamente utiliza el enfoque de dos pasos: Whisper transcribe las palabras, y luego GPT-4o analiza el texto resultante, esta vez específicamente instruido para buscar capas implícitas.
Descarga el audio de muestra: https://files.cuantum.tech/audio/implicit_speech.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:21 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-12 16:21:00 CDT" # Updated time
current_location = "Dallas, Texas, United States"
print(f"Running GPT-4o implicit speech understanding example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file with implicit meaning
# IMPORTANT: Replace 'implicit_speech.mp3' with the actual filename.
audio_file_path = "implicit_speech.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Analyze Transcribed Text for Implicit Meaning using GPT-4o ---
def analyze_implicit_meaning(client, text_to_analyze):
"""
Sends transcribed text to GPT-4o to analyze implicit meanings,
assumptions, references, or rhetorical devices.
"""
print("\nStep 2: Analyzing transcribed text for implicit meaning...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed for identifying implicit communication layers
system_prompt = "You are an expert analyst of human communication, skilled at identifying meaning that is implied but not explicitly stated."
user_prompt = f"""Analyze the following statement or question:
Statement/Question:
---
{text_to_analyze}
---
Based on common knowledge, cultural context, and conversational patterns, please explain:
1. Any underlying assumptions the speaker might be making.
2. Any implicit meanings or suggestions conveyed beyond the literal words.
3. Any cultural references, idioms, or sayings being used or alluded to.
4. If it's a rhetorical question, what point is likely being made?
Provide a breakdown of the implicit layers of communication present:
"""
try:
print("Sending text to GPT-4o for implicit meaning analysis...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for deep understanding
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=400, # Adjust as needed
temperature=0.5 # Allow for some interpretation
)
analysis = response.choices[0].message.content
print("Implicit meaning analysis successful.")
return analysis.strip()
except OpenAIError as e:
print(f"OpenAI API Error during analysis: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during analysis: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio
transcribed_text = transcribe_speech(client, audio_file_path)
if transcribed_text:
print(f"\n--- Transcription Result ---")
print(transcribed_text)
print("----------------------------")
# Step 2: Analyze the transcription for implicit meaning
implicit_analysis = analyze_implicit_meaning(
client,
transcribed_text
)
if implicit_analysis:
print("\n--- Implicit Meaning Analysis ---")
print(implicit_analysis)
print("-------------------------------")
print("\nThis demonstrates GPT-4o identifying meaning beyond the literal text, based on common knowledge and context.")
else:
print("\nImplicit meaning analysis failed.")
else:
print("\nTranscription failed, cannot proceed to implicit meaning analysis.")Desglose del código:
- Contexto: Este ejemplo de código demuestra la capacidad de GPT-4o para la Comprensión Implícita – captar las suposiciones no expresadas, referencias y significados integrados en el lenguaje hablado.
- Proceso en dos pasos: Sigue el patrón establecido:
- Paso 1 (Whisper): Transcribir el audio que contiene el discurso con significado implícito a texto usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): Analizar el texto transcrito usando
client.chat.completions.create, con un prompt específicamente diseñado para descubrir capas ocultas de significado.
- Paso 1 (Whisper): Transcribir el audio que contiene el discurso con significado implícito a texto usando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio donde el significado depende del conocimiento compartido, contexto cultural, o no es completamente literal (por ejemplo, usando un modismo, una pregunta retórica, o haciendo una suposición clara solo por contexto). Se usaimplicit_speech.mp3como marcador de posición. - Función de Transcripción (
transcribe_speech): Maneja el Paso 1, devolviendo la transcripción en texto plano. - Función de Análisis Implícito (
analyze_implicit_meaning):- Maneja el Paso 2, tomando el texto transcrito.
- Ingeniería de Prompts para Significado Implícito: El prompt es clave aquí. Instruye a GPT-4o para mirar más allá de las palabras literales e identificar suposiciones subyacentes, sugerencias implícitas, referencias culturales/modismos, y el propósito detrás de preguntas retóricas.
- Utiliza
gpt-4opor su extensa base de conocimientos y capacidad de razonamiento necesaria para inferir estos elementos implícitos.
- Salida: La función devuelve el análisis textual de GPT-4o de los significados no expresados detectados en el texto de entrada.
- Ejecución Principal: El script transcribe el audio, pasa el texto para análisis implícito, e imprime tanto la transcripción literal como la interpretación de GPT-4o de los significados ocultos.
- Relevancia del Caso de Uso: Esto demuestra cómo GPT-4o puede procesar la comunicación de manera más similar a un humano, entendiendo no solo lo que se dijo, sino también lo que se quiso decir o se asumió. Esto es crucial para aplicaciones que requieren comprensión profunda, como analizar feedback de usuarios, entender diálogos con matices en reuniones, o interpretar contenido culturalmente rico.
Recuerda usar un archivo de audio que contenga habla que requiera cierto nivel de inferencia o conocimiento previo para entenderlo completamente al probar este código. Reemplaza 'implicit_speech.mp3' con tu ruta de archivo.
De la Transcripción a la Comprensión Integral
Este avance marca una transformación revolucionaria en la capacidad de la IA para procesar el habla humana. Mientras que los sistemas tradicionales como Whisper sobresalen en la transcripción - el proceso mecánico de convertir palabras habladas en texto escrito - los sistemas modernos de IA como GPT-4o logran una verdadera comprensión, entendiendo no solo las palabras en sí, sino su significado más profundo, contexto e implicaciones. Este salto adelante permite a la IA procesar la comunicación humana de manera notablemente similar a cómo los humanos entienden naturalmente la conversación, incluyendo sutiles matices, significados implícitos y relevancia contextual.
Para ilustrar esta evolución transformadora en capacidad, examinemos un ejemplo detallado que resalta el marcado contraste entre la simple transcripción y la comprensión avanzada:
- Consideremos esta declaración: "Creo que deberíamos retrasar el lanzamiento del producto hasta el próximo trimestre." Un sistema de transcripción tradicional como Whisper capturaría perfectamente estas palabras, pero ahí es donde termina su comprensión - simplemente convierte el habla a texto con alta precisión.
- GPT-4o, sin embargo, demuestra un nivel sofisticado de comprensión que refleja la comprensión humana:
- Análisis del Mensaje Principal: Más allá de solo identificar la sugerencia de reprogramación, lo entiende como una propuesta estratégica que requiere consideración cuidadosa
- Evaluación del Impacto Empresarial: Evalúa exhaustivamente cómo este retraso afectaría varios aspectos del negocio, desde la asignación de recursos hasta la programación del equipo y las implicaciones presupuestarias
- Análisis Estratégico del Mercado: Examina el contexto más amplio del mercado, incluyendo movimientos de la competencia, tendencias del mercado y potenciales ventanas de oportunidad
- Evaluación Integral de Riesgos: Evalúa las consecuencias tanto inmediatas como a largo plazo, considerando todo, desde la preparación técnica hasta el posicionamiento en el mercado
Lo que hace verdaderamente notable a GPT-4o es su capacidad para participar en discusiones analíticas matizadas sobre el contenido, abordando preguntas estratégicas complejas que requieren comprensión profunda:
- Factores Externos: ¿Qué condiciones específicas del mercado, presiones competitivas o tendencias de la industria podrían haber motivado esta sugerencia de retraso?
- Impacto en los Interesados: ¿Cómo afectaría este ajuste de cronograma las relaciones con inversores, socios y clientes? ¿Qué estrategias de comunicación podrían ser necesarias?
- Oportunidades Estratégicas: ¿Qué ventajas potenciales podrían surgir de este retraso, como desarrollo adicional de características u optimización del momento de lanzamiento al mercado?
2.3.2 ¿Qué puede hacer GPT-4o con entrada de voz?
GPT-4o representa un avance significativo en la tecnología de procesamiento de audio, ofreciendo un conjunto integral de capacidades que transforman cómo interactuamos y entendemos el contenido hablado. Como un modelo de lenguaje de vanguardia con capacidades de procesamiento multimodal, combina reconocimiento sofisticado del habla con comprensión contextual profunda para ofrecer potentes características de análisis de audio. Exploremos algunas otras funciones y capacidades de GPT-4o:
Extracción de Elementos de Acción
Ejemplo de prompt: "Enumera todas las tareas mencionadas en esta nota de voz."
GPT-4o sobresale en identificar y extraer elementos de acción del contenido hablado a través del procesamiento sofisticado del lenguaje natural. El modelo puede:
- Analizar conversaciones complejas para detectar tanto tareas explícitas ("Por favor haz X") como implícitas ("Deberíamos considerar Y")
- Distinguir entre discusiones hipotéticas y compromisos reales
- Categorizar tareas por prioridad, fecha límite y responsable
- Identificar dependencias entre diferentes elementos de acción
- Señalar requisitos de seguimiento y tareas recurrentes
Esta capacidad transforma discusiones de audio no estructuradas en listas de tareas estructuradas y accionables, mejorando significativamente la productividad de las reuniones y el seguimiento. Al mantener automáticamente un registro completo de compromisos, asegura la responsabilidad mientras reduce la carga cognitiva de los participantes que de otro modo necesitarían rastrear estos elementos manualmente. El sistema también puede integrarse con herramientas populares de gestión de tareas, haciendo que sea sencillo convertir asignaciones habladas en tickets o tareas rastreables.
Ejemplo:
Este script utiliza el proceso familiar de dos pasos: primero transcribiendo el audio con Whisper, luego analizando el texto con GPT-4o usando un prompt específicamente diseñado para identificar y estructurar elementos de acción.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/meeting_tasks.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:39 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-03-24 10:29:00 CDT" # Updated time
current_location = "Plano, Texas, United States"
print(f"Running GPT-4o action item extraction from speech example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_tasks.mp3' with the actual filename.
audio_file_path = "meeting_tasks.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before extraction.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Extract Action Items from Text using GPT-4o ---
def extract_action_items(client, text_to_analyze):
"""Sends transcribed text to GPT-4o for action item extraction."""
print("\nStep 2: Extracting action items...")
if not text_to_analyze:
print("Error: No text provided for extraction.")
return None
# Prompt designed specifically for extracting structured action items
system_prompt = "You are an expert meeting analyst focused on identifying actionable tasks."
user_prompt = f"""Analyze the following meeting or discussion transcription. Identify and extract all specific action items mentioned.
For each action item, provide:
- A clear description of the task.
- The person assigned (if mentioned, otherwise state 'Unassigned' or 'Group').
- Any deadline mentioned (if mentioned, otherwise state 'No deadline mentioned').
Distinguish between definite commitments/tasks and mere suggestions or hypothetical possibilities. Only list items that sound like actual tasks or commitments.
Format the output as a numbered list.
Transcription Text:
---
{text_to_analyze}
---
Extracted Action Items:
"""
try:
print("Sending text to GPT-4o for action item extraction...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong analytical capabilities
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=500, # Adjust based on expected number of action items
temperature=0.1 # Very low temperature for factual extraction
)
extracted_actions = response.choices[0].message.content
print("Action item extraction successful.")
return extracted_actions.strip()
except OpenAIError as e:
print(f"OpenAI API Error during extraction: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during extraction: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Extract Action Items
action_items_list = extract_action_items(
client,
full_transcription
)
if action_items_list:
print("\n--- Extracted Action Items ---")
print(action_items_list)
print("------------------------------")
print("\nThis demonstrates GPT-4o identifying and structuring actionable tasks from the discussion.")
else:
print("\nFailed to extract action items.")
else:
print("\nTranscription failed, cannot proceed to action item extraction.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para extraer elementos de acción del contenido hablado. Después de transcribir el audio con Whisper, GPT-4o analiza el texto para identificar tareas específicas, asignaciones y fechas límite discutidas.
- Proceso en dos pasos: Utiliza el flujo de trabajo estándar:
- Paso 1 (Whisper): Transcribe el audio de la reunión/discusión (
client.audio.transcriptions.create) a texto. La nota sobre el manejo de archivos de audio > 25MB mediante segmentación/concatenación sigue siendo crítica para uso real. - Paso 2 (GPT-4o): Analiza la transcripción completa usando
client.chat.completions.createcon un prompt adaptado para la extracción de tareas.
- Paso 1 (Whisper): Transcribe el audio de la reunión/discusión (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio de una reunión donde se asignaron tareas (meeting_tasks.mp3). - Función de transcripción (
transcribe_speech): Maneja el Paso 1. - Función de extracción de elementos de acción (
extract_action_items):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de prompts para tareas: Este es el núcleo. El prompt instruye explícitamente a GPT-4o para identificar elementos de acción, distinguirlos de meras sugerencias, y extraer la descripción de la tarea, la persona asignada (si se menciona), y la fecha límite (si se menciona). Solicita un formato de lista numerada estructurada. Se recomienda una
temperaturemuy baja (por ejemplo, 0.1) para mantener la salida enfocada en la extracción factual. - Utiliza
gpt-4opor su capacidad para entender el contexto conversacional e identificar compromisos.
- Salida: La función devuelve una cadena de texto que contiene la lista estructurada de elementos de acción extraídos.
- Ejecución principal: El script transcribe el audio, pasa el texto a la función de extracción e imprime la lista resultante de tareas.
- Relevancia del caso de uso: Esto aborda directamente la capacidad de "Extracción de elementos de acción". Muestra cómo la IA puede convertir automáticamente discusiones verbales no estructuradas en listas de tareas organizadas y ejecutables. Esto aumenta significativamente la productividad al garantizar el seguimiento, clarificar responsabilidades y reducir el esfuerzo manual de rastrear compromisos hechos durante las reuniones. Destaca la capacidad de GPT-4o para analizar conversaciones complejas e identificar asignaciones de tareas tanto explícitas como implícitas.
Preguntas y respuestas sobre el audio
Ejemplo de prompt: "¿Qué dijo el orador sobre el presupuesto?"
Las capacidades avanzadas de consulta de GPT-4o permiten conversaciones naturales sobre contenido de audio, permitiendo a los usuarios hacer preguntas específicas y recibir respuestas contextualmente relevantes. El modelo puede:
- Extraer información precisa de segmentos específicos
- Comprender el contexto y las referencias a lo largo de todo el audio
- Manejar preguntas de seguimiento sobre temas previamente discutidos
- Proporcionar referencias con marca de tiempo a las partes relevantes
- Hacer referencias cruzadas de información de múltiples partes de la grabación
Esta funcionalidad transforma la forma en que interactuamos con el contenido de audio, haciéndolo tan buscable y consultable como los documentos de texto. En lugar de revisar manualmente las grabaciones, los usuarios pueden simplemente hacer preguntas en lenguaje natural y recibir respuestas precisas y concisas. El sistema es particularmente valioso para:
- Participantes de reuniones que necesitan verificar detalles específicos
- Investigadores analizando grabaciones de entrevistas
- Estudiantes revisando contenido de conferencias
- Profesionales verificando conversaciones con clientes
- Equipos que buscan entender discusiones históricas
Ejemplo:
Este script primero transcribe un archivo de audio usando Whisper y luego utiliza GPT-4o para responder una pregunta específica realizada por el usuario sobre el contenido de esa transcripción.
Descarga el ejemplo de audio: https://files.cuantum.tech/audio/meeting_for_qa.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:47 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-01-11 11:47:00 CDT" # Updated time
current_location = "Orlando, Florida, United States"
print(f"Running GPT-4o Q&A about audio example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'meeting_for_qa.mp3' with the actual filename.
audio_file_path = "meeting_for_qa.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before Q&A.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Answer Question Based on Text using GPT-4o ---
def answer_question_about_text(client, full_text, question):
"""Sends transcribed text and a question to GPT-4o to get an answer."""
print(f"\nStep 2: Answering question about the transcription...")
print(f"Question: \"{question}\"")
if not full_text:
print("Error: No transcription text provided to answer questions about.")
return None
if not question:
print("Error: No question provided.")
return None
# Prompt designed specifically for answering questions based on provided text
system_prompt = "You are an AI assistant specialized in answering questions based *only* on the provided text transcription. Do not use outside knowledge."
user_prompt = f"""Based *solely* on the following transcription text, please answer the question below. If the answer is not found in the text, state that clearly.
Transcription Text:
---
{full_text}
---
Question: {question}
Answer:
"""
try:
print("Sending transcription and question to GPT-4o...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong comprehension and answering
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=300, # Adjust based on expected answer length
temperature=0.1 # Low temperature for factual answers based on text
)
answer = response.choices[0].message.content
print("Answer generation successful.")
return answer.strip()
except OpenAIError as e:
print(f"OpenAI API Error during Q&A: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during Q&A: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
transcription = transcribe_speech(client, audio_file_path)
if transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(transcription[:1000] + "..." if len(transcription) > 1000 else transcription)
print("------------------------------------")
# --- Ask Questions about the Transcription ---
# Define the question(s) you want to ask
user_question = "What was decided about the email marketing CTA button?"
# user_question = "Who is responsible for the A/B test on Platform B?"
# user_question = "What was the engagement increase on Platform A?"
print(f"\n--- Answering Question ---")
# Step 2: Get the answer from GPT-4o
answer = answer_question_about_text(
client,
transcription,
user_question
)
if answer:
print(f"\nAnswer to '{user_question}':")
print(answer)
print("------------------------------")
print("\nThis demonstrates GPT-4o answering specific questions based on the transcribed audio content.")
else:
print(f"\nFailed to get an answer for the question: '{user_question}'")
else:
print("\nTranscription failed, cannot proceed to Q&A.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para funcionar como un sistema de preguntas y respuestas para contenido de audio. Después de transcribir el habla con Whisper, los usuarios pueden hacer preguntas específicas en lenguaje natural, y GPT-4o proporcionará respuestas basadas en la información contenida en la transcripción.
- Proceso en dos pasos: El flujo de trabajo incluye:
- Paso 1 (Whisper): Transcribir el archivo de audio relevante (o texto concatenado de fragmentos de un archivo más largo) usando
client.audio.transcriptions.create. - Paso 2 (GPT-4o): Enviar la transcripción completa junto con la pregunta específica del usuario a
client.chat.completions.create.
- Paso 1 (Whisper): Transcribir el archivo de audio relevante (o texto concatenado de fragmentos de un archivo más largo) usando
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que contenga la discusión o información sobre la que el usuario podría hacer preguntas (meeting_for_qa.mp3). La nota crítica sobre el manejo de audio >25MB mediante fragmentación/concatenación antes del paso de preguntas y respuestas sigue siendo esencial. - Función de transcripción (
transcribe_speech): Maneja el Paso 1. - Función de preguntas y respuestas (
answer_question_about_text):- Maneja el Paso 2, tomando tanto la transcripción
full_textcomo laquestioncomo entrada. - Ingeniería de prompt para preguntas y respuestas: El prompt es crucial. Instruye a GPT-4o para que actúe como un asistente especializado que responde preguntas basándose únicamente en el texto de transcripción proporcionado, indicándole explícitamente que no use conocimiento externo y que indique si la respuesta no se encuentra en el texto. Este fundamento es importante para la precisión. Una
temperaturebaja (por ejemplo, 0.1) ayuda a garantizar respuestas factuales derivadas directamente del texto fuente. - Utiliza
gpt-4opor su excelente comprensión lectora y capacidades de preguntas y respuestas.
- Maneja el Paso 2, tomando tanto la transcripción
- Salida: La función devuelve la respuesta de GPT-4o a la pregunta específica realizada.
- Ejecución principal: El script transcribe el audio, define una
user_questionde ejemplo, pasa la transcripción y la pregunta a la función de preguntas y respuestas, e imprime la respuesta resultante. - Relevancia de caso de uso: Esto aborda directamente la capacidad de "Preguntas y respuestas sobre el audio". Transforma las grabaciones de audio de archivos pasivos a fuentes de conocimiento interactivas. Los usuarios pueden encontrar rápidamente detalles específicos, verificar hechos o entender partes de una discusión sin buscar manualmente en el audio, haciéndolo invaluable para revisar reuniones, conferencias, entrevistas o cualquier conversación grabada.
Recuerde usar un archivo de audio que contenga información relevante para las posibles preguntas de prueba (puede usar el audio de muestra proporcionado). Modifique la variable user_question para probar diferentes consultas contra el contenido transcrito.
Destacar momentos clave
Ejemplo de prompt: "Identifique las declaraciones más importantes realizadas en este audio."
GPT-4o sobresale en identificar y extraer momentos cruciales del contenido de audio a través de sus capacidades avanzadas de comprensión del lenguaje natural. El modelo puede:
- Identificar decisiones clave y elementos de acción
- Extraer citas y declaraciones importantes
- Resaltar discusiones estratégicas y conclusiones
- Señalar transiciones críticas en conversaciones
Esta función es particularmente valiosa para:
- Participantes de reuniones que necesitan revisar rápidamente puntos importantes
- Ejecutivos que examinan grabaciones largas en busca de puntos de decisión
- Equipos que rastrean hitos de proyectos discutidos en llamadas
- Investigadores que identifican momentos significativos en entrevistas
El modelo proporciona marcas de tiempo y resúmenes contextuales para cada momento destacado, facilitando la navegación directa a las partes más relevantes de la grabación sin revisar todo el archivo de audio.
Ejemplo:
Este script sigue el patrón establecido de dos pasos: transcribir el audio con Whisper y luego analizar el texto con GPT-4o usando un prompt diseñado para identificar declaraciones significativas, decisiones o conclusiones.
Descargue el audio de ejemplo: https://files.cuantum.tech/audio/key_discussion.mp3
import os
from openai import OpenAI, OpenAIError
from dotenv import load_dotenv
import datetime
# --- Configuration ---
# Load environment variables (especially OPENAI_API_KEY)
load_dotenv()
# Get the current date and location context
# Current time is Monday, April 21, 2025 at 8:52 PM CDT.
# Current location is Little Elm, Texas, United States.
current_timestamp = "2025-02-14 15:52:00 CDT" # Updated time
current_location = "Tampa, Florida, United States"
print(f"Running GPT-4o key moment highlighting example at: {current_timestamp}")
print(f"Location Context: {current_location}")
# Initialize the OpenAI client
try:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OPENAI_API_KEY not found in environment variables.")
client = OpenAI(api_key=api_key)
print("OpenAI client initialized.")
except ValueError as e:
print(f"Configuration Error: {e}")
exit()
except Exception as e:
print(f"Error initializing OpenAI client: {e}")
exit()
# Define the path to your audio file (or audio chunk)
# IMPORTANT: Replace 'key_discussion.mp3' with the actual filename.
audio_file_path = "key_discussion.mp3"
# --- Step 1: Transcribe Speech to Text using Whisper ---
# Reusing the function from previous examples
def transcribe_speech(client, file_path):
"""Transcribes the audio file using Whisper."""
print(f"\nStep 1: Transcribing audio file: {file_path}")
if not os.path.exists(file_path):
print(f"Error: Audio file not found at '{file_path}'")
return None
# Add note about chunking for long files if size check implemented
try:
file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
print(f"File size: {file_size_mb:.2f} MB (Limit: 25MB per API call)")
if file_size_mb > 25:
print("Warning: File exceeds 25MB. For full content, chunking and multiple transcriptions are needed before highlighting.")
except OSError:
pass # Ignore size check error
try:
with open(file_path, "rb") as audio_file:
response = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print("Transcription successful.")
return response # Returns plain text
except OpenAIError as e:
print(f"OpenAI API Error during transcription: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during transcription: {e}")
return None
# --- Step 2: Highlight Key Moments from Text using GPT-4o ---
def highlight_key_moments(client, text_to_analyze):
"""Sends transcribed text to GPT-4o to identify and extract key moments."""
print("\nStep 2: Identifying key moments from transcription...")
if not text_to_analyze:
print("Error: No text provided for analysis.")
return None
# Prompt designed specifically for identifying key moments/statements
system_prompt = "You are an expert analyst skilled at identifying the most significant parts of a discussion or presentation."
user_prompt = f"""Analyze the following transcription text. Identify and extract the key moments, which could include:
- Important decisions made
- Critical conclusions reached
- Significant statements or impactful quotes
- Major topic shifts or transitions
- Key questions asked or answered
For each key moment identified, provide the relevant quote or a concise summary of the moment. Present the output as a list.
Transcription Text:
---
{text_to_analyze}
---
Key Moments:
"""
try:
print("Sending text to GPT-4o for key moment identification...")
response = client.chat.completions.create(
model="gpt-4o", # Use GPT-4o for strong comprehension
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
max_tokens=700, # Adjust based on expected number/length of key moments
temperature=0.3 # Lean towards factual identification
)
key_moments = response.choices[0].message.content
print("Key moment identification successful.")
return key_moments.strip()
except OpenAIError as e:
print(f"OpenAI API Error during highlighting: {e}")
return None
except Exception as e:
print(f"An unexpected error occurred during highlighting: {e}")
return None
# --- Main Execution ---
if __name__ == "__main__":
# Step 1: Transcribe the audio discussion (or chunk)
full_transcription = transcribe_speech(client, audio_file_path)
if full_transcription:
print(f"\n--- Full Transcription (Preview) ---")
# Limit printing very long transcripts in the example output
print(full_transcription[:1000] + "..." if len(full_transcription) > 1000 else full_transcription)
print("------------------------------------")
# Step 2: Highlight Key Moments
highlights = highlight_key_moments(
client,
full_transcription
)
if highlights:
print("\n--- Identified Key Moments ---")
print(highlights)
print("----------------------------")
print("\nThis demonstrates GPT-4o extracting significant parts from the discussion.")
print("\nNote: Adding precise timestamps to these moments requires further processing using Whisper's 'verbose_json' output and correlating the text.")
else:
print("\nFailed to identify key moments.")
else:
print("\nTranscription failed, cannot proceed to highlight key moments.")Desglose del código:
- Contexto: Este código demuestra la capacidad de GPT-4o para Resaltar Momentos Clave del contenido hablado. Después de la transcripción mediante Whisper, GPT-4o analiza el texto para identificar y extraer las partes más significativas, como decisiones cruciales, declaraciones importantes o cambios importantes de tema.
- Proceso en dos pasos:
- Paso 1 (Whisper): Transcribir el audio (
client.audio.transcriptions.create) para obtener el texto completo. Se reitera la necesidad de segmentar/concatenar para archivos de audio > 25MB. - Paso 2 (GPT-4o): Analizar la transcripción completa usando
client.chat.completions.createcon un prompt específicamente diseñado para momentos clave.
- Paso 1 (Whisper): Transcribir el audio (
- Requisitos previos: Configuración estándar (
openai,python-dotenv, clave API) y un archivo de audio que contenga una discusión o presentación donde ocurran momentos significativos (key_discussion.mp3). - Función de Transcripción (
transcribe_speech): Maneja el Paso 1. - Función de Resaltado (
highlight_key_moments):- Maneja el Paso 2, tomando el texto completo de la transcripción.
- Ingeniería de Prompt para Resaltados: El prompt instruye a GPT-4o a actuar como analista e identificar varios tipos de momentos clave (decisiones, conclusiones, citas impactantes, transiciones). Solicita la cita relevante o un resumen conciso para cada momento identificado, formateado como lista.
- Utiliza
gpt-4opor su capacidad para discernir importancia y contexto dentro del texto.
- Salida: La función devuelve una cadena de texto que contiene la lista de momentos clave identificados.
- Nota sobre Marcas de Tiempo: La explicación y salida del código mencionan explícitamente que mientras este proceso identifica el texto de los momentos clave, agregar marcas de tiempo precisas requeriría pasos adicionales. Esto implica usar el formato
verbose_jsonde Whisper (que incluye marcas de tiempo por segmento) y luego correlacionar el texto identificado por GPT-4o con esos segmentos cronometrados específicos – una tarea más compleja no cubierta en este ejemplo básico. - Ejecución Principal: El script transcribe el audio, pasa el texto a la función de resaltado e imprime la lista resultante de momentos clave.
- Relevancia de Caso de Uso: Esto aborda la capacidad de "Resaltar Momentos Clave" al mostrar cómo la IA puede examinar rápidamente grabaciones potencialmente largas para destacar las partes más críticas. Esto es altamente valioso para la revisión eficiente de reuniones, entrevistas o conferencias, permitiendo a los usuarios enfocarse en lo más importante sin escuchar todo el audio.
Para propósitos de prueba, use un archivo de audio que contenga una discusión relevante con segmentos clave claros e identificables (puede usar el archivo de audio de muestra proporcionado).
2.3.3 Casos de Uso del Mundo Real
El panorama empresarial moderno depende cada vez más de la comunicación por audio en varios sectores, desde ventas y servicio al cliente hasta educación y desarrollo personal. Comprender y utilizar eficazmente estas interacciones de audio se ha vuelto crucial para las organizaciones que buscan mejorar sus operaciones, fortalecer las relaciones con los clientes e impulsar mejores resultados. Esta sección explora varias aplicaciones clave donde el procesamiento y análisis avanzado de audio puede crear un valor significativo, demostrando cómo las herramientas potenciadas por IA pueden transformar datos de audio sin procesar en información procesable.
Desde el análisis de conversaciones de ventas hasta la mejora de experiencias educativas, estos casos de uso muestran la versatilidad y el poder de las tecnologías de comprensión de audio para abordar desafíos del mundo real. Cada aplicación representa una oportunidad única para aprovechar los datos de voz para mejorar la toma de decisiones, optimizar procesos y mejorar las experiencias de usuario.
1. Potenciación de Ventas
El análisis avanzado de grabaciones de llamadas de ventas proporciona un conjunto completo de herramientas para que los equipos de ventas optimicen su rendimiento. El sistema puede identificar objeciones clave planteadas por los prospectos, permitiendo a los equipos desarrollar mejores contraargumentos y preparar respuestas por adelantado. Rastrea técnicas de cierre exitosas analizando patrones en acuerdos exitosos, revelando qué enfoques funcionan mejor para diferentes segmentos de clientes y situaciones.
El sistema también mide métricas cruciales como tasas de conversión, duración de llamadas, proporción de habla-escucha y uso de frases clave. Estos datos ayudan a los equipos de ventas a entender qué comportamientos se correlacionan con resultados exitosos. Al analizar las respuestas de los clientes y patrones de reacción, los equipos pueden refinar el momento de sus presentaciones, mejorar sus técnicas de preguntas y comprender mejor las señales de compra.
Esta tecnología también permite a los gerentes de ventas documentar y compartir enfoques efectivos en todo el equipo, creando una base de conocimientos de mejores prácticas para desafíos comunes. Este conocimiento institucional puede ser particularmente valioso para la incorporación de nuevos miembros del equipo y mantener la excelencia consistente en ventas en toda la organización.
2. Inteligencia de Reuniones
El análisis integral de reuniones transforma la manera en que las organizaciones capturan y utilizan el contenido de las reuniones. El sistema va más allá de la transcripción básica al:
- Identificar y categorizar puntos clave de discusión para fácil referencia
- Detectar y extraer automáticamente elementos de acción de las conversaciones
- Asignar responsabilidades a miembros específicos del equipo basado en compromisos verbales
- Crear líneas de tiempo estructuradas y rastrear plazos mencionados durante las reuniones
- Generar listas automatizadas de tareas con clara propiedad y fechas de vencimiento
- Resaltar puntos de decisión y resultados de reuniones
- Proporcionar archivos de reuniones con capacidad de búsqueda para referencia futura
El sistema emplea procesamiento avanzado de lenguaje natural para comprender contexto, relaciones y compromisos expresados durante las conversaciones. Esto permite la creación y asignación automática de tareas, asegurando que nada se pierda. La integración con herramientas de gestión de proyectos permite la automatización fluida del flujo de trabajo, mientras que los recordatorios inteligentes ayudan a mantener a los miembros del equipo responsables de sus compromisos.
3. Soporte al Cliente
El análisis profundo de interacciones de servicio al cliente proporciona información integral sobre la experiencia del cliente y el rendimiento del equipo de soporte. El sistema puede:
- Evaluar el sentimiento del cliente en tiempo real analizando tono, elección de palabras y flujo de conversación
- Categorizar y priorizar automáticamente problemas urgentes basado en detección de palabras clave y análisis de contexto
- Generar métricas detalladas de satisfacción a través del análisis de conversaciones y retroalimentación del cliente
- Rastrear indicadores clave de rendimiento como tiempo de primera respuesta y tiempo de resolución
- Identificar puntos de dolor comunes y problemas recurrentes a través de múltiples interacciones
- Monitorear el rendimiento del agente de soporte y la consistencia en la entrega del servicio
Esto permite a los equipos de soporte mejorar los tiempos de respuesta, identificar problemas tendencia y mantener una calidad de servicio consistente en todas las interacciones. El sistema también puede proporcionar sugerencias automáticas de entrenamiento para agentes de soporte y generar información para la mejora del producto basada en patrones de retroalimentación del cliente.
4. Diario Personal
Transforma las notas de voz en reflexiones estructuradas con análisis de contexto emocional. Utilizando procesamiento avanzado de lenguaje natural, el sistema analiza las grabaciones de voz para detectar estados emocionales, niveles de estrés y sentimiento general a través del tono de voz, elección de palabras y patrones de habla. Esto crea una entrada de diario multidimensional y rica que captura no solo lo que se dijo, sino cómo se expresó.
Las capacidades de seguimiento del estado de ánimo del sistema van más allá de simples clasificaciones positivas/negativas, identificando estados emocionales con matices como entusiasmo, incertidumbre, confianza o preocupación. Al analizar estos patrones a lo largo del tiempo, los usuarios pueden obtener información valiosa sobre su bienestar emocional e identificar desencadenantes o patrones que afectan su estado mental.
Para el seguimiento de objetivos personales, el sistema puede categorizar y etiquetar automáticamente menciones de objetivos, actualizaciones de progreso y contratiempos. Puede generar informes de progreso que muestran el impulso hacia objetivos específicos, destacar obstáculos comunes e incluso sugerir posibles soluciones basadas en estrategias exitosas anteriores. El análisis de tendencias conductuales examina patrones en la toma de decisiones, formación de hábitos y crecimiento personal, proporcionando a los usuarios información práctica para la superación personal.
5. Educación y Práctica de Idiomas
El apoyo integral al aprendizaje de idiomas revoluciona la forma en que los estudiantes practican y mejoran sus habilidades lingüísticas. El sistema proporciona varios beneficios clave:
- Análisis del Habla: Los algoritmos avanzados analizan patrones de pronunciación, detectando variaciones sutiles en fonemas, patrones de acentuación y entonación. Esto ayuda a los estudiantes a entender exactamente dónde su pronunciación difiere de los hablantes nativos.
- Detección de Errores: El sistema identifica no solo errores de pronunciación, sino también errores gramaticales, uso incorrecto de palabras y problemas sintácticos en tiempo real. Esta retroalimentación inmediata ayuda a prevenir la formación de malos hábitos.
- Retroalimentación Personalizada: En lugar de correcciones genéricas, el sistema proporciona retroalimentación contextual que considera el nivel de competencia del estudiante, su idioma nativo y patrones de interferencia comunes específicos de su origen lingüístico.
- Seguimiento del Progreso: Métricas sofisticadas rastrean varios aspectos del desarrollo del lenguaje, incluyendo rango de vocabulario, fluidez al hablar, precisión gramatical y mejora en la pronunciación a lo largo del tiempo. Los informes visuales de progreso ayudan a motivar a los estudiantes e identificar áreas que necesitan atención.
- Aprendizaje Adaptativo: Basado en el análisis de rendimiento, el sistema crea planes de ejercicios personalizados dirigidos a debilidades específicas. Estos pueden incluir ejercicios focalizados de pronunciación, ejercicios gramaticales o actividades de construcción de vocabulario adaptadas a las necesidades del estudiante.
El sistema puede rastrear la mejora a lo largo del tiempo y sugerir ejercicios específicos para las áreas que necesitan mejora, creando un entorno de aprendizaje dinámico y receptivo que se adapta al progreso de cada estudiante.
2.3.4 Consideraciones de Privacidad
La privacidad es primordial al manejar grabaciones de audio. En primer lugar, obtener el consentimiento antes de analizar grabaciones de voz de terceros es un requisito legal y ético crucial. Es esencial asegurar el permiso escrito o documentado de todos los participantes antes de procesar cualquier grabación de voz, ya sean de reuniones, entrevistas, llamadas u otro contenido de audio que involucre a terceros. Las organizaciones deben implementar un proceso formal de consentimiento que describa claramente cómo se utilizará y analizará el audio.
Se deben implementar medidas de seguridad a lo largo del flujo de trabajo de procesamiento. Después de completar el análisis, es crítico usar openai.files.delete(file_id) para eliminar los archivos de audio de los servidores de OpenAI. Esta práctica minimiza la exposición de datos y ayuda a prevenir el acceso no autorizado y posibles violaciones de datos. Las organizaciones deben establecer procedimientos automatizados de limpieza para asegurar la eliminación consistente de archivos procesados.
El almacenamiento a largo plazo de datos de voz requiere consideración especial. Nunca almacene grabaciones de voz sensibles sin la aprobación explícita de todas las partes involucradas. Las organizaciones deben implementar políticas estrictas de manejo de datos que especifiquen claramente la duración del almacenamiento, medidas de seguridad y uso previsto. Se debe tener especial cuidado con las grabaciones que contengan información personal, secretos comerciales o discusiones confidenciales. Las mejores prácticas incluyen implementar encriptación para archivos de audio almacenados y mantener registros detallados de acceso.