¿Qué es Skeleton of Thoughts y su implementación en Python?

Introducción

Imagina tener todo el potencial de tu asistente de IA favorito, transformándolo de una herramienta útil en una potencia creativa. Imagina un mundo en el que tus interacciones con los modelos de lenguaje grandes (LLM) sean eficientes, profundamente intuitivas e impactantes. Entra en el Skeleton of Thoughts (SoT), un marco innovador preparado para revolucionar la inteligencia artificial y el procesamiento del lenguaje natural. Examinemos esta intrigante idea con más detalle y veamos cómo podría mejorar tus procesos creativos y de resolución de problemas impulsados ​​por IA.

Descripción general

1. El marco Skeleton of Thoughts (SoT) transforma la IA en una potencia creativa con esquemas estructurados pero adaptables para tareas complejas.
2. SoT permite que la IA aborde los desafíos con claridad y profundidad al proporcionar un marco conceptual flexible.
3. Los elementos centrales de SoT incluyen esquemas estructurados, expansión flexible, pensamiento jerárquico, desarrollo iterativo y enlaces cruzados.
4. La implementación de SoT implica crear un esquema esquelético, expandir puntos y conectar partes utilizando el modelo GPT de OpenAI.
5. SoT ofrece claridad, escalabilidad, flexibilidad, comprensión holística y exploración eficiente de temas complejos.
6. Las aplicaciones del SoT en el mundo real incluyen la investigación académica, el desarrollo de productos y la planificación estratégica para la exploración estructurada de temas complejos.

Revelando el esqueleto del pensamiento

¿Qué pasaría si pudiéramos construir un marco conceptual de IA que permitiera flexibilidad y creatividad y, al mismo tiempo, guiara el proceso de pensamiento del modelo? Ese es precisamente el objetivo del Skeleton of Thoughts. SoT permite a los modelos de IA abordar desafíos con una claridad, coherencia y profundidad sin precedentes al proporcionar un esquema estructurado pero adaptable para tareas complejas.

El concepto central de SoT

1. Esquema estructurado: Una estructura de alto nivel que describe los elementos principales de la tarea.
2. Expansión flexible: Todos los componentes del esqueleto se pueden mejorar y ampliar según sea necesario.
3. Pensamiento jerárquico: Las ideas están organizadas en una estructura lógica y anidada.
4. Desarrollo iterativo: El esqueleto cambia a medida que la IA investiga y refina los conceptos.
5. Reticulación: Son posibles conexiones creadas dinámicamente entre varios componentes del esqueleto.

Implementando el esqueleto de pensamientos

Hagamos realidad este concepto con un Pitón Implementación que aprovecha de OpenAI Modelo GPT:

Prerrequisitos y configuración

!pip install openai --upgrade

Importación de bibliotecas

from openai importOpenAI
import openai 
import time 
import re
from IPython.display import Markdown, display

Configuración de la clave API

os.environ("OPENAI_API_KEY")= “Your openAPIKey”

from openai import OpenAI
from openai import OpenAI
import time
import re

class SkeletonOfThoughts:
    """
    A class to create and manipulate a skeletal outline using OpenAI's API.
    """


    def __init__(self, api_key, model="gpt-3.5-turbo"):
        """
        Initialize the SkeletonOfThoughts object.


        Args:
            api_key (str): OpenAI API key
            model (str): OpenAI model to use (default is "gpt-3.5-turbo")
        """
        self.client = OpenAI(api_key=api_key)
        self.model = model
        self.skeleton = {}


    def create_skeleton(self, topic):
        """
        Create a skeletal outline for the given topic.


        topic (str): The topic to create a skeleton for


        Returns:
            dict: The created skeleton outline
        """
        prompt = f"""Create a detailed skeletal outline for the topic: '{topic}'.
        Use the following format:
        1. Main point
        1.1. Subpoint
        1.2. Subpoint
        2. Main point
        2.1. Subpoint
        2.2. Subpoint
        Provide at least 3 main points with 2-3 subpoints each."""
        try:
            response = self.execute_prompt(prompt, max_tokens=500)
            print(f"Raw API Response:\n{response}")  # Debug print
            self.skeleton = self.parse_skeleton(response)
            print(f"Parsed Skeleton:\n{self.skeleton}")  # Debug print
            return self.skeleton
        except Exception as e:
            print(f"Error creating skeleton: {str(e)}")
            return {}


    def expand_point(self, point_number):
        """
        Expand a specific point in the skeleton.


   
            point_number (int): The number of the point to expand


        Returns:
            str: The expanded point content
        """
        point_key = self.find_point_key(point_number)
        if point_key is None:
            return f"Point {point_number} not found in the skeleton."
        current_content = self.skeleton(point_key)
        prompt = f"Expand on the following point: {current_content}"
        expansion = self.execute_prompt(prompt)
        self.skeleton(point_key) = f"{current_content}\n{expansion}"
        return self.skeleton(point_key)


    def add_cross_link(self, point1, point2):
        """
        Add a cross-link between two points in the skeleton.


  
         point1 (int): The number of the first point
         point2 (int): The number of the second point


        Returns:
            str: The created cross-link explanation
        """
        key1 = self.find_point_key(point1)
        key2 = self.find_point_key(point2)
        if key1 is None or key2 is None:
            return "One or both points not found in the skeleton."
        prompt = f"Explain how these two points are related: 1) {self.skeleton(key1)} 2) {self.skeleton(key2)}"
        link = self.execute_prompt(prompt)
        link_key = f"Link: {key1} - {key2}"
        self.skeleton(link_key) = link
        return link


    def execute_prompt(self, prompt, max_tokens=500):
        """
        Execute a prompt using the OpenAI API.


        
            prompt (str): The prompt to send to the API
            max_tokens (int): Maximum number of tokens in the response


        Returns:
            str: The API response content
        """
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=(
                    {"role": "system", "content": "You are an ai assistant creating a structured outline."},
                    {"role": "user", "content": prompt}
                ),
                max_tokens=max_tokens
            )
            content = response.choices(0).message.content.strip()
            print(f"API Response Content:\n{content}")  # Debug print
            return content
        except Exception as e:
            print(f"Error executing prompt: {str(e)}")
            return ""


    def parse_skeleton(self, text):
        """
        Parse the skeleton text into a structured dictionary.


       
            text (str): The raw skeleton text to parse


        Returns:
            dict: The parsed skeleton structure
        """
        print("Parsing text:", text)  # Debug print
        lines = text.split('\n')
        skeleton = {}
        current_main_point = ""
        for line in lines:
            line = line.strip()
            if not line:
                continue


            # Match main points (1., 2., etc.)
            main_point_match = re.match(r'^(\d+\.)\s*(.*)', line)
            if main_point_match:
                current_main_point = main_point_match.group(1)
                skeleton(current_main_point) = main_point_match.group(2)


            # Match subpoints (1.1., 1.2., 2.1., etc.)
            subpoint_match = re.match(r'^(\d+\.\d+\.)\s*(.*)', line)
            if subpoint_match:
                subpoint_key = subpoint_match.group(1)
                skeleton(subpoint_key) = subpoint_match.group(2)


            # If it's not a numbered point, add it to the current main point
            elif current_main_point and line:
                skeleton(current_main_point) += " " + line


        return skeleton


    def find_point_key(self, point_number):
        """
        Find the key in the skeleton dictionary for a given point number.


         point_number (int): The point number to find


        Returns:
            str: The key in the skeleton dictionary, or None if not found
        """
        for key in self.skeleton.keys():
            if key.startswith(str(point_number) + '.'):
                return key
        return None


    def display_skeleton(self):
        """
        Display the current skeleton structure.
        """
        if not self.skeleton:
            print("The skeleton is empty.")
        else:
            for key, value in self.skeleton.items():
                print(f"{key} {value}\n")


def main():
    """
    Main function to demonstrate the usage of SkeletonOfThoughts class.
    """
    api_key = key  # Replace with your actual OpenAI API key
    if api_key == "your-api-key-here":
        print("Please replace 'your-api-key-here' with your actual OpenAI API key.")
        return


    try:
        sot = SkeletonOfThoughts(api_key)


        topic = "The Impact of artificial intelligence on Future Job Markets"
        print(f"Creating skeleton for topic: {topic}")
        initial_skeleton = sot.create_skeleton(topic)


        if not initial_skeleton:
            print("Failed to create initial skeleton. Please check the error messages above.")
            return


        print("\nInitial Skeleton:")
        sot.display_skeleton()


        # Expand a point
        print("\nExpanding Point 1:")
        expanded_point = sot.expand_point(1)
        print(expanded_point)


        # Add a cross-link
        print("\nAdding Cross-link between points 1 and 2:")
        link = sot.add_cross_link(1, 2)
        print(link)


        print("\nFinal Skeleton:")
        sot.display_skeleton()


    except Exception as e:
        print(f"An error occurred: {str(e)}")


if __name__ == "__main__":
    main()

Producción Con explicación

Creando esqueleto: El sistema creó un esquema detallado para el tema “El impacto de la inteligencia artificial en los mercados laborales futuros”. Este esquema incluye puntos principales y subpuntos que cubren varios aspectos del impacto de la IA en los mercados laborales.

Esqueleto inicial: Se muestra el esqueleto analizado, que muestra la estructura del esquema con puntos principales y subpuntos. Sin embargo, parece haber algunos problemas de análisis, ya que algunos subpuntos están asociados incorrectamente con los puntos principales.

Punto de expansión 1: El sistema amplió el primer punto, brindando una explicación detallada de la definición de Inteligencia Artificial. Esta ampliación incluye qué es la IA, sus componentes, posibles impactos y consideraciones éticas.

Añadiendo enlace cruzado entre los puntos 1 y 2: El sistema conectó el primer punto (Definición de IA) y el segundo punto (Debate sobre la capacitación y el reciclaje profesional), y explicó cómo estos puntos se relacionan a través de su enfoque compartido sobre el impacto de la IA en los empleos y la fuerza laboral.

Esqueleto final: El esqueleto final combina todos los pasos anteriores. Incluye el esquema inicial, el primer punto ampliado y el vínculo entre los puntos 1 y 2. Esto proporciona una estructura integral para analizar el impacto de la IA en los mercados laborales futuros.

Esta implementación da vida al Esqueleto de Pensamientos:

1. Hemos creado una clase Skeleton Of Thoughts que encapsula nuestro enfoque, inicializada con una clave API de OpenAI y una elección de modelo (predeterminada en “gpt3.5-turbo”).
2. El método create_skeleton genera un esquema inicial para un tema determinado:
   • Utiliza un formato de mensaje específico para garantizar una respuesta estructurada de la IA.
   • El método maneja las interacciones de la API y analiza la respuesta en una estructura de diccionario.
3. expand_point permite una exploración más profunda de puntos específicos en el esqueleto:
   • Identifica el punto a expandir en función de su número.
   • Luego, el método genera contenido adicional para ese punto utilizando la IA.
4. add_cross_link establece conexiones entre diferentes partes del esqueleto:
   • Toma dos números de punto como entrada y explica su relación.
   • Luego, el enlace se agrega al esqueleto como una nueva entrada.
5. El esqueleto se almacena como un diccionario, con claves que representan números de puntos (por ejemplo, “1.”, “1.1.”) y valores que contienen el contenido.
6. Los métodos auxiliares adicionales mejoran la funcionalidad:
   • execute_prompt maneja llamadas API con gestión de errores y salida de depuración.
   • parse_skeleton convierte la respuesta de texto de la IA en un diccionario estructurado.
   • find_point_key localiza puntos específicos en el esqueleto.
   • display_skeleton imprime el estado actual del esqueleto.

La magia de SoT en acción

Analicemos lo que sucede cuando ejecutamos este código:

1. Creación inicial del esqueleto
   • La IA genera un esquema de alto nivel para el tema dado (por ejemplo, “El impacto de la IA en los mercados laborales futuros”).
   • Este esquema incluye puntos principales y subpuntos, formateados como una lista numerada.
2. Expansión de puntos
   • Podemos profundizar en puntos específicos (por ejemplo, el punto 1) utilizando el método expand_point.
   • La IA proporciona información más detallada sobre el punto elegido.
3. Enlace cruzado
   • Las conexiones entre diferentes partes del esqueleto se establecen mediante add_cross_link.
   • Por ejemplo, podemos vincular los puntos 1 y 2, generando una explicación de su relación.
4. Desarrollo iterativo
   • El esqueleto se puede perfeccionar continuamente ampliando puntos o añadiendo enlaces cruzados.
   • Cada operación actualiza el diccionario esqueleto, lo que permite la creación de conocimiento acumulativo.
5. Manejo robusto de errores
   • La implementación incluye una amplia verificación de errores y salida de depuración.
   • Esto ayuda a identificar y abordar problemas con las llamadas API o el análisis.

Este enfoque estructurado pero flexible permite una exploración más integral e interconectada de temas complejos. El uso de la IA para generar contenido y la estructura programática para organizar y vincular ideas crea una herramienta poderosa para el desarrollo y análisis del pensamiento.

Lea también estos artículos de Prompt Engineering:

Consulta más artículos aquí – Prompt Engineering.

Ventajas del Esqueleto de Pensamientos

Estas son las ventajas del esqueleto de pensamientos:

1. Claridad y organización: Las ideas están estructuradas de manera lógica y fácil de seguir.
2. Escalabilidad: El esqueleto puede ser tan simple o tan complejo como lo requiera la tarea.
3. Flexibilidad: Fácil de adaptar y perfeccionar a medida que surgen nuevos conocimientos.
4. Comprensión holística: La reticulación promueve una comprensión más completa del tema.
5. Exploración eficiente: Proporciona una hoja de ruta para una investigación exhaustiva sin perderse en los detalles.

Aplicaciones en el mundo real

Aquí están las aplicaciones del mundo real:

1. Investigación académica: Imagine utilizar SoT para esbozar un trabajo de investigación complejo. El esqueleto podría proporcionar las secciones y subsecciones principales, con la capacidad de ampliar los puntos clave y establecer conexiones entre las diferentes partes del argumento.
2. Desarrollo de productos: En la industria tecnológica, SoT podría usarse para trazar las características y componentes de un nuevo producto, permitiendo a los equipos visualizar la estructura general y profundizar en detalles específicos según sea necesario.
3. Planificación estratégica: Las empresas podrían utilizar SoT para desarrollar estrategias integrales, describiendo los objetivos principales, los desafíos potenciales y los planes de acción, con la flexibilidad de expandir y conectar diferentes aspectos de la estrategia.

Desafíos y consideraciones

Si bien el Esqueleto de Pensamientos ofrece posibilidades apasionantes, es importante tener en cuenta lo siguiente:

1. Equilibrio entre estructura y flexibilidad: Encontrar el equilibrio adecuado entre proporcionar una estructura clara y permitir la exploración creativa.
2. Gestión de la complejidad: Gestionar el crecimiento y las interconexiones del esqueleto puede resultar un desafío para temas muy grandes o complejos.
3. Limitaciones de la IA: La calidad y las expansiones del esqueleto aún están limitadas por las capacidades del modelo de lenguaje subyacente.

El futuro de la ingeniería rápida

A medida que la IA avanza, técnicas como el esqueleto de pensamientos mejorarán nuestra capacidad para abordar problemas complejos y explorar temas intrincados. Proporcionar un marco estructurado pero flexible para el pensamiento asistido por IA abre nuevas posibilidades para la organización del conocimiento, la resolución de problemas y la exploración creativa.

Conclusión

El esqueleto de los pensamientos representa un paso importante en la estructuración y la orientación de los procesos de pensamiento asistidos por IA. Al proporcionar un andamiaje flexible para las ideas, podemos explorar temas complejos con una claridad y una profundidad sin precedentes, manteniendo al mismo tiempo la capacidad de adaptar y refinar nuestro enfoque a medida que surgen nuevos conocimientos.

Ya seas un investigador, un estratega de negocios o alguien a quien le encanta explorar ideas, el método del esqueleto de pensamientos ofrece una nueva y poderosa herramienta para organizar y desarrollar tus pensamientos. ¿Por qué no lo pruebas? ¡Quizás descubras una nueva forma de pensar que transforme tu forma de abordar temas y desafíos complejos!

Preguntas frecuentes