Desarrollo de modelos grandes (15): cree un proceso de desarrollo de proyectos de IA altamente automatizado de 0 a 1 (Parte 1)

El texto completo tiene un total de más de 5600 palabras y el tiempo de lectura esperado es de aproximadamente 13 a 20 minutos | Lleno de productos secos (con todos los códigos), ¡se recomienda marcarlo como favorito!

El objetivo de este artículo: proponer una solución para acelerar la eficiencia del desarrollo de proyectos mediante el uso de modelos de lenguaje grandes (LLM). Este artículo, como primera parte, se centra principalmente en cómo implementar completamente todo el proceso de guiar el modelo de Chat para crear códigos de función externos, gestión de códigos y pruebas.

Dirección de descarga de código

1. Antecedentes

En este artículo, desarrollo de modelos a gran escala (catorce): el uso del modelo OpenAI Chat + API de Google para implementar una aplicación de IA para el envío y recepción de correos electrónicos inteligentes ha realizado el proceso de desarrollo de aplicaciones de IA en torno a la API de Google Cloud Gmail, aunque dos se definen en El proceso es una función de automatización clave, pero para el proceso de desarrollo de IA, se requiere más exploración y requisitos. Se necesita intervención de IA para aplicar el modelo de lenguaje grande al proceso de desarrollo de software para mejorar la eficiencia del desarrollo de software. El modelo de lenguaje en sí es muy popular en la actualidad.Dirección de aplicación . La poderosa capacidad de comprensión de la intención humana y la capacidad de escritura de código del modelo de lenguaje grande permitirá a los ingenieros de desarrollo mejorar en gran medida la eficiencia del desarrollo con el soporte del modelo de lenguaje grande.

Para el desarrollo de aplicaciones de IA, el uso de modelos de lenguaje grandes para mejorar la eficiencia del desarrollo se puede dividir en las dos etapas siguientes: la implementación en este artículo es un caso de implementación típico de la segunda etapa.

Basado en el proceso de la segunda etapa mencionado anteriormente, este artículo utiliza el proyecto de desarrollo de aplicaciones de IA de correo electrónico previamente implementado para ver cómo usar el modelo de lenguaje grande para acelerar la eficiencia del desarrollo del proyecto.

2. Escribe funciones externas con la ayuda de ChatGPT.

Utilizando el modelo Chat para ayudar a mejorar la eficiencia del desarrollo de aplicaciones de IA, una de las estrategias más básicas es intentar dejar que el modelo Chat complete la escritura de funciones externas para las funciones correspondientes. Un método de implementación relativamente simple es hacer preguntas directamente en ChatGPT después de clasificar los requisitos, dejar que genere el código de la función externa y luego copiarlo al entorno de código actual para probarlo y modificarlo.

Por ejemplo, si escribe una función para ver los últimos 5 correos electrónicos recibidos en torno a la llamada de la API de Gmail, puede hacer preguntas a ChatGPT de la siguiente manera:

Inmediato:

Ahora obtuve la API de Gmail, realicé la autorización y el cliente OAuth 2.0, y guardé las credenciales para ver el correo como un archivo token.json. Ahora quiero escribir una función para ver los últimos n correos electrónicos. Los requisitos de la función son los siguientes:
1. Los parámetros de la función son n y userId, donde userId es un parámetro de cadena y el valor predeterminado es "yo", lo que significa ver mis correos electrónicos. Y n es un número entero, que representa el número de correos electrónicos que se consultarán;
2. El resultado devuelto por la función es una lista que contiene varios diccionarios, expresada en formato json, donde un diccionario representa un mensaje de correo electrónico y cada diccionario debe contener correos electrónicos
3. Encapsule todas las funciones en una función
Ayúdeme a escribir un documento de descripción detallada de la función durante el proceso de escritura de la función, utilizando Se utiliza para describir información como funciones de función, parámetros de función y retorno de función. resultados;

La función generada por ChatGPT es la siguiente, puede intentar ejecutarla y unificar el archivo de autorización de la API de Gmail antes de realizar la prueba:

SCOPES = ['https://www.googleapis.com/auth/gmail.send','https://www.googleapis.com/auth/gmail.readonly']
flow = InstalledAppFlow.from_client_secrets_file(
                'credentials-web.json', SCOPES)
creds = flow.run_local_server(port=8000, access_type='offline', prompt='consent')

with open('token.json', 'w') as token:
    token.write(creds.to_json())

import base64
import re
import json
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

def get_recent_emails(n, userId='me'):
    """
    获取最近的n封邮件
    
    功能：
        这个函数用于获取最近的n封邮件信息。返回的邮件信息包括邮件的发件人、发件时间、邮件主题和邮件内容。
    
    参数：
        n (int)：需要获取的邮件数量。
        userId (str)：用户ID。默认值为'me'，代表当前授权用户。
    
    返回：
        返回一个包含多个字典的列表，以json格式表示。每个字典对应一封邮件信息，包括邮件的发件人、发件时间、邮件主题和邮件内容。
    """
    
    # If modifying these SCOPES, delete the file token.json.
    SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']

    creds = None
    if os.path.exists('token.json'):
        creds = Credentials.from_authorized_user_file('token.json')
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        # Save the credentials for the next run
        with open('token.json', 'w') as token:
            token.write(creds.to_json())

    service = build('gmail', 'v1', credentials=creds)
    
    # Get the recent n emails
    results = service.users().messages().list(userId=userId, maxResults=n).execute()
    messages = results.get('messages', [])
    
    email_list = []
    for message in messages:
        msg = service.users().messages().get(userId=userId, id=message['id']).execute()
        
        email_data = msg['payload']['headers']
        
        for values in email_data:
            name = values['name']
            if name == 'From':
                from_name = values['value']
            if name == 'Date':
                date = values['value']
            if name == 'Subject':
                subject = values['value']
                
        try:
            payload = msg['payload']
            body = payload['body']
            data = body['data']
            data = data.replace("-","+").replace("_","/")
            decoded_data = base64.b64decode(data)
            soup = BeautifulSoup(decoded_data , "lxml")
            body_text = soup.body()
            body_text = body_text[0].replace('\r\n', ' ').replace('\n', ' ')
        except:
            body_text = "Not available"
        
        email_dict = {
    
    'Date': date, 'From': from_name, 'Subject': subject, 'Body': body_text}
        email_list.append(email_dict)
    
    return json.dumps(email_list, indent=4, ensure_ascii=False)

La salida es esta:

Luego pruebe si el modelo de Chat puede interpretar el resultado de dicha función:

response = openai.ChatCompletion.create(
  model="gpt-4-0613",
  messages=[
    {
    
    "role": "system", "content": "这是我的Gmail邮箱最近五封邮件的内容：%s" % msg},
    {
    
    "role": "system", "content": "邮件内容是由Gmail API获取"},
    {
    
    "role": "user", "content": "请问我的Gmail最近五封邮件是谁发送的，都有什么内容？"}
  ]
)
response.choices[0].message['content']

El resultado es el siguiente:

El modelo Chat puede obtener con éxito la recepción de estos 5 correos electrónicos y continuar con las pruebas. A continuación, pruebe la función get_emails escrita por ChatGPT. Sus parámetros indican si puede ser reconocido por la función auto_functions y cree parámetros de funciones. El código es el siguiente:

Primero importe la función auto_functions:

def auto_functions(functions_list):
    """
    Chat模型的functions参数编写函数
    :param functions_list: 包含一个或者多个函数对象的列表；
    :return：满足Chat模型functions参数要求的functions对象
    """
    def functions_generate(functions_list):
        # 创建空列表，用于保存每个函数的描述字典
        functions = []
        
        def chen_ming_algorithm(data):
            """
            陈明算法函数，该函数定义了一种特殊的数据集计算过程
            :param data: 必要参数，表示带入计算的数据表，用字符串进行表示
            :return：陈明函数计算后的结果，返回结果为表示为JSON格式的Dataframe类型对象
            """
            df_new = pd.read_json(data)
            res = np.sum(df_new, axis=1) - 1
            return res.to_json(orient='records')
        
        chen_ming_function_description = inspect.getdoc(chen_ming_algorithm)
        
        chen_ming_function_name = chen_ming_algorithm.__name__
        
        chen_ming_function = {
    
    "name": "chen_ming_algorithm",
                              "description": "用于执行陈明算法的函数，定义了一种特殊的数据集计算过程",
                              "parameters": {
    
    "type": "object",
                                             "properties": {
    
    "data": {
    
    "type": "string",
                                                                     "description": "执行陈明算法的数据集"},
                                                           },
                                             "required": ["data"],
                                            },
                             }

        
        # 对每个外部函数进行循环
        for function in functions_list:
            # 读取函数对象的函数说明
            function_description = inspect.getdoc(function)
            # 读取函数的函数名字符串
            function_name = function.__name__

            user_message1 = '以下是某函数说明：%s。' % chen_ming_function_description +\
                            '根据这个函数的函数说明，请帮我创建一个function对象，用于描述这个函数的基本情况。这个function对象是一个JSON格式的字典，\
                            这个字典有如下5点要求：\
                            1.字典总共有三个键值对；\
                            2.第一个键值对的Key是字符串name，value是该函数的名字：%s，也是字符串；\
                            3.第二个键值对的Key是字符串description，value是该函数的函数的功能说明，也是字符串；\
                            4.第三个键值对的Key是字符串parameters，value是一个JSON Schema对象，用于说明该函数的参数输入规范。\
                            5.输出结果必须是一个JSON格式的字典，只输出这个字典即可，前后不需要任何前后修饰或说明的语句' % chen_ming_function_name
            
            
            assistant_message1 = json.dumps(chen_ming_function)
            
            user_prompt = '现在有另一个函数，函数名为：%s；函数说明为：%s；\
                          请帮我仿造类似的格式为当前函数创建一个function对象。' % (function_name, function_description)

            response = openai.ChatCompletion.create(
                              model="gpt-4-0613",
                              messages=[
                                {
    
    "role": "user", "name":"example_user", "content": user_message1},
                                {
    
    "role": "assistant", "name":"example_assistant", "content": assistant_message1},
                                {
    
    "role": "user", "name":"example_user", "content": user_prompt}]
                            )
            functions.append(json.loads(response.choices[0].message['content']))
        return functions
    
    max_attempts = 3
    attempts = 0

    while attempts < max_attempts:
        try:
            functions = functions_generate(functions_list)
            break  # 如果代码成功执行，跳出循环
        except Exception as e:
            attempts += 1  # 增加尝试次数
            print("发生错误：", e)
            if attempts == max_attempts:
                print("已达到最大尝试次数，程序终止。")
                raise  # 重新引发最后一个异常
            else:
                print("正在重新运行...")
    return functions

functions_list = [get_emails]
functions = auto_functions(functions_list)
functions

Mira los resultados:

A continuación, pruebe la función de funciones para indicar si puede ser reconocida correctamente por el modelo de Chat:

response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
    
    "role": "user", "content": '请帮我查下最近3封邮件的邮件内容'}],
        functions=functions,
        function_call="auto",  
    )
response

Mira el efecto:

En general, en el proceso anterior de escribir funciones externas con la ayuda de ChatGPT, se han hecho un total de tres cosas:

• Obtenga primero las credenciales relacionadas con la API y ejecute todo el proceso de autorización de la API.
• Basado en una buena comprensión de la función de llamada de función y el conjunto de funciones_automáticas, envíe un recordatorio razonable a ChatGPT.
• Después de obtener la función escrita por ChatGPT, use auto_functions para verificar la función de la función externa

3. Utilice el modelo de chat para realizar la operación del código local.

Escribir funciones externas con la ayuda de ChatGPT puede acelerar en gran medida la eficiencia del desarrollo de aplicaciones de IA, pero no es muy IA hacer preguntas a ChatGPT cada vez y luego copiar y pegar el código localmente para su verificación . Por lo tanto, es necesario crear códigos de función externos directamente en el entorno del código a través de indicaciones en lenguaje natural, y probarlos y encapsularlos automáticamente .

Para hacer esto, primero debe ejecutar la función creada por el modelo de Chat y ejecutar el proceso directamente.

3.1 Los resultados de salida del modelo de chat se convierten directamente en código y se ejecutan

La entrada y la salida del modelo de Chat son cadenas, por lo que si desea que la salida del modelo de Chat se convierta directamente en una función externa que se pueda ejecutar, no solo necesita un mensaje razonable, sino también algunos métodos que puedan extraer. El código Python en la cadena y ejecutarlo directamente. Un proceso de prueba relativamente simple es:

• Paso 1: compruebe si el modelo gpt-4-0613 utilizado actualmente puede crear una función que cumpla con los requisitos de funciones externas bajo indicaciones razonables.

response = openai.ChatCompletion.create(
  model="gpt-4-0613",
  messages=[{
    
    "role": "system", "content": "你是一个python代码编辑器，你的功能是输出python代码，请勿输出任何和python代码无关的内容"},
            {
    
    "role": "user", "content": "请帮我定义一个python函数，输出Hello world字符串，请在函数编写过程中，在函数内部加入中文编写的详细的函数说明文档。"}
  ]
)

Mira el resultado:

• Paso 2: La cadena generada por el modelo Chat es un objeto con formato Markdown, guárdelo en formato md.

Vea cómo se ve el código formateado, el código es el siguiente:

with open('helloworld.md', 'a', encoding='utf-8') as f:
    f.write(response.choices[0].message['content'])

Mire el contenido de helloworld.md:

• Paso 3: encapsular la función

No hay ningún problema con la función creada por el modelo Chat en sí, pero si desea llamarla directamente localmente, después de muchos intentos, una forma más eficiente de resolver el problema es extraer solo Python de la cadena anterior mediante expresiones regulares. cadena del código , el código es el siguiente:

def extract_code(s):
    """
    如果输入的字符串s是一个包含Python代码的Markdown格式字符串，提取出代码部分。
    否则，返回原字符串。

    参数:
    s: 输入的字符串。

    返回:
    提取出的代码部分，或原字符串。
    """
    # 判断字符串是否是Markdown格式
    if '```python' in s or 'Python' in s or'PYTHON' in s:
        # 找到代码块的开始和结束位置
        code_start = s.find('def')
        code_end = s.find('```\n', code_start)
        # 提取代码部分
        code = s[code_start:code_end]
    else:
        # 如果字符串不是Markdown格式，返回原字符串
        code = s

    return code

Pruebe el resultado de la ejecución:

code_s = extract_code(response.choices[0].message['content'])
code_s

De hecho, se puede ver aquí que la parte del código contenida en s se puede extraer completamente y guardar como una cadena. Para un programa Python representado por una cadena, puede escribirlo en un archivo py local y ver el código de la siguiente manera:

with open('helloworld.py', 'w', encoding='utf-8') as f:
    f.write(code_s)

En este punto, se creará localmente un archivo py que guarda la función print_hello_world:

En resumen, un proceso automático completo debe tener las siguientes capacidades:

• Defina una función extract_function_code completa. Esta función puede extraer el código Python en la cadena, extraer el nombre de la función del código y guardar la función localmente en el archivo py al mismo tiempo.

• Al guardar, se divide en dos archivos, probado y no probado. La carpeta probada se usa para guardar funciones verificadas manualmente y la carpeta no probada se usa para guardar funciones que no han sido verificadas, y cada función se llama function_name_module.py.

• Al ejecutar esta función, el código (que define la función) se ejecutará en el entorno actual y, al mismo tiempo, puede optar por imprimir toda la información de la función o simplemente imprimir el nombre de la función.

Según los requisitos funcionales anteriores, una función de ejemplo es la siguiente:

def extract_function_code(s, detail=0, tested=False):
    """
    函数提取函数，同时执行函数内容，可以选择打印函数信息，并选择代码保存的地址
    """
    def extract_code(s):
        """
        如果输入的字符串s是一个包含Python代码的Markdown格式字符串，提取出代码部分。
        否则，返回原字符串。

        参数:
        s: 输入的字符串。

        返回:
        提取出的代码部分，或原字符串。
        """
        # 判断字符串是否是Markdown格式
        if '```python' in s or 'Python' in s or'PYTHON' in s:
            # 找到代码块的开始和结束位置
            code_start = s.find('def')
            code_end = s.find('```\n', code_start)
            # 提取代码部分
            code = s[code_start:code_end]
        else:
            # 如果字符串不是Markdown格式，返回原字符串
            code = s

        return code
    
    # 提取代码字符串
    code = extract_code(s)
    
    # 提取函数名称
    match = re.search(r'def (\w+)', code)
    function_name = match.group(1)
    
    # 将函数写入本地
    if tested == False:
        with open('./functions/untested functions/%s_module.py' % function_name, 'w', encoding='utf-8') as f:
            f.write(code)
    else:
        with open('./functions/tested functions/%s_module.py' % function_name, 'w', encoding='utf-8') as f:
            f.write(code)
    
    # 执行该函数
    try:
        exec(code, globals())
    except Exception as e:
        print("An error occurred while executing the code:")
        print(e)
    
    # 打印函数名称
    if detail == 0:
        print("The function name is:%s" % function_name)
    
    if detail == 1:
        with open('%s.py' % function_name, encoding='utf-8') as f:
            content = f.read()
        print(content)

Con esta función, es más conveniente extraer, guardar y ejecutar los resultados del modelo de Chat con un solo clic.

3.2 Escribir funciones externas con la ayuda de la función Chat

Sobre la base de este proceso, puede intentar guiar la función de chat para que escriba directamente funciones externas que cumplan con los requisitos. Aquí, se toma como ejemplo la función de contar el número de todos los correos electrónicos en el buzón .

La función get_latest_email previamente definida es la siguiente:

def get_latest_email(userId):
    """
    查询Gmail邮箱中最后一封邮件信息
    :param userId: 必要参数，字符串类型，用于表示需要查询的邮箱ID，\
    注意，当查询我的邮箱时，userId需要输入'me'；
    :return：包含最后一封邮件全部信息的对象，该对象由Gmail API创建得到，且保存为JSON格式
    """
    # 从本地文件中加载凭据
    creds = Credentials.from_authorized_user_file('token.json')
    
    # 创建 Gmail API 客户端
    service = build('gmail', 'v1', credentials=creds)
    
    # 列出用户的一封最新邮件
    results = service.users().messages().list(userId=userId, maxResults=1).execute()
    messages = results.get('messages', [])

    # 遍历邮件
    for message in messages:
        # 获取邮件的详细信息
        msg = service.users().messages().get(userId='me', id=message['id']).execute()
        
    return json.dumps(msg)

• Paso 1: extraiga directamente el código de la función anterior a través de inspect.getsource y envíelo en formato de cadena . El código es el siguiente:

code = inspect.getsource(get_latest_email)

Mira el resultado:

• Paso 2: indíquelo en el modo Few-shot

Primero lea la información de descripción de la función, el código es el siguiente:

# 写入本地
with open('./functions/tested functions/%s_module.py' % 'get_latest_email', 'w', encoding='utf-8') as f:
    f.write(code)

# 从本地读取
with open('./functions/tested functions/%s_module.py' % 'get_latest_email', encoding='utf-8') as f:
    content = f.read()

Los datos leídos son los siguientes:

Entonces el mensaje final es el siguiente:

assistant_example_content = content

system_content = "我现在已完成Gmail API授权，授权文件为本地文件token.json。"

user_example_content = "请帮我编写一个python函数，用于查看我的Gmail邮箱中最后一封邮件信息，函数要求如下：\
                        1.函数参数userId，userId是字符串参数，默认情况下取值为'me'，表示查看我的邮件；\
                        2.函数返回结果是一个包含最后一封邮件信息的对象，返回结果本身必须是一个json格式对象；\
                        3.请将全部功能封装在一个函数内；\
                        4.请在函数编写过程中，在函数内部加入中文编写的详细的函数说明文档，用于说明函数功能、函数参数情况以及函数返回结果等信息；"

user_content = "请帮我编写一个python函数，用于查看我的Gmail邮箱中总共有多少封邮件，函数要求如下：\
                1.函数参数userId，userId是字符串参数，默认情况下取值为'me'，表示查看我的邮件；\
                2.函数返回结果是当前邮件总数，返回结果本身必须是一个json格式对象；\
                3.请将全部功能封装在一个函数内；\
                4.请在函数编写过程中，在函数内部加入中文编写的详细的函数说明文档，用于说明函数功能、函数参数情况以及函数返回结果等信息；"

messages=[{
    
    "role": "system", "content": system_content},
          {
    
    "role": "user", "name":"example_user", "content": user_example_content},
          {
    
    "role": "assistant", "name":"example_assistant", "content": assistant_example_content},
          {
    
    "role": "user", "name":"example_user", "content": user_content}]

El método de indicación del modelo Chat es muy diferente del de ChatGPT. Cuando se transmite el mismo significado, los métodos de indicación efectivos de los dos también pueden ser muy diferentes, por lo que el método de indicación específico debe probarse repetidamente. Lo anterior es solo una forma de pensar, todavía hay mucho margen de mejora.

• Paso 3: llama al modelo

response = openai.ChatCompletion.create(
  model="gpt-4-0613",
  messages=messages
)

Eche un vistazo al resultado:

• Paso 4: después de extraer el código, escríbalo localmente

extract_function_code(res, detail=0)

Mira el código local:

• Paso 5: ejecutar la validación de la función

Esta función puede contar correctamente el número de correos electrónicos en el buzón actual.

• Paso 6: Pruebe si la función se puede convertir correctamente en un parámetro de funciones

functions_list = [get_email_count]

functions = auto_functions(functions_list)
functions

Mira el resultado:

• Paso 7: Pruebe si el modelo de Chat puede reconocer correctamente la descripción de la función

response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
    
    "role": "user", "content": '请帮我查下Gmail邮箱里现在总共有多少封邮件'}],
        functions=functions,
        function_call="auto",  
    )
response

Mira el resultado:

Hasta ahora, se ha escrito la función de contar el número total de correos electrónicos. En comparación con el proceso anterior, la eficiencia de escribir funciones externas ya es muy alta con la ayuda de la función extract_function_code. Solo requiere una pequeña cantidad de trabajo manual para escribir indicaciones y probar nuevas funciones para completar la escritura de funciones externas.

3.3 Guardar función

Para el proceso de desarrollo mencionado anteriormente, cuando se ha probado la función **, se puede transferir a la carpeta probada, lo que indica que el modelo de lenguaje grande puede reconocer con éxito la función y llamarla como una función externa. **el código se muestra a continuación:

import shutil
import os
import glob

def functions_move(module_name):
    """
    将通过测试的函数转移到tested functions文件夹内
    """
    current_directory = os.getcwd()
    src_dir = current_directory + "\\functions\\untested functions"
    dst_dir = current_directory + "\\functions\\tested functions"

    src_file = os.path.join(src_dir, module_name)
    dst_file = os.path.join(dst_dir, module_name)

    shutil.move(src_file, dst_file)

Cuatro Resumen

Este artículo, como el primer paso en la optimización eficiente del proceso de desarrollo de IA, ejecuta completamente todo el proceso de guiar el modelo de Chat para crear códigos de funciones externas, administración de códigos y pruebas.

Pero, de hecho, el proceso de desarrollo de aplicaciones de IA puede ser más eficiente, por ejemplo, frente a una gran cantidad de necesidades potenciales de usuarios desconocidos (por ejemplo, ahora quiero comprobar si hay correos electrónicos no leídos de alguien en el buzón). , una mejor idea es utilizar modelos de lenguaje grande (LLM), traducir instantáneamente las necesidades del usuario en indicaciones creadas por funciones externas y luego crear instantáneamente funciones externas y agregarlas al modelo de Chat para actualizar las capacidades del modelo de Chat en tiempo real. y finalmente proporcionar una solución más completa . Esta es una forma más avanzada de automatización, de modo que el modelo grande no solo puede escribir el código para la realización de funciones, sino que también el proceso desde el requisito hasta la función puede resumirse en el propio modelo grande. Si esto se puede lograr, la función de este producto equivale a realizar el autocrecimiento (crecimiento en tiempo real según las necesidades de los usuarios), no hay duda de que dicho proceso de desarrollo se acerca más al proceso de desarrollo inteligente imaginado.

Finalmente, ¡gracias por leer este artículo! Si sientes que has ganado algo, no olvides darle me gusta, marcarlo y seguirme, esta es la motivación para mi creación continua. Si tiene alguna pregunta o sugerencia, puede dejar un mensaje en el área de comentarios, haré todo lo posible para responder y aceptar sus comentarios. Si hay un tema en particular que le gustaría conocer, hágamelo saber y estaré encantado de escribir un artículo al respecto. ¡Gracias por su apoyo y esperamos crecer con usted!

Artículo siguiente¡Continúe con la optimización de procesos!