%pip install --upgrade openai
	
	

		
	

	

		
%pip install --upgrade openai
import openai
	
	

		
	

	

		
%pip install --upgrade openai
import openai
api_key = "Pon aquí tu API key"
	
	

		
	

	

		
%pip install --upgrade openai
import openai
api_key = "Pon aquí tu API key"
model = "gpt-3.5-turbo-1106"
	
	

		
	

	

		
%pip install --upgrade openai
import openai
api_key = "Pon aquí tu API key"
model = "gpt-3.5-turbo-1106"
client = openai.OpenAI(api_key=api_key, organization=None)
	
	

		
	

	

		
%pip install --upgrade openai
import openai
api_key = "Pon aquí tu API key"
model = "gpt-3.5-turbo-1106"
client = openai.OpenAI(api_key=api_key, organization=None)
promtp = "Cuál es el mejor lenguaje de programación para aprender?"
	
	

		
	

	

		
%pip install --upgrade openai
import openai
api_key = "Pon aquí tu API key"
model = "gpt-3.5-turbo-1106"
client = openai.OpenAI(api_key=api_key, organization=None)
promtp = "Cuál es el mejor lenguaje de programación para aprender?"
response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": f"{promtp}"}],
      )
	
	

		
	

	

		
%pip install --upgrade openai
import openai
api_key = "Pon aquí tu API key"
model = "gpt-3.5-turbo-1106"
client = openai.OpenAI(api_key=api_key, organization=None)
promtp = "Cuál es el mejor lenguaje de programación para aprender?"
response = client.chat.completions.create(
  model=model,
  messages=[{"role": "user", "content": f"{promtp}"}],
)
type(response), response
	
	

		
	

	

		
(openai.types.chat.chat_completion.ChatCompletion,
 ChatCompletion(id='chatcmpl-8RaHCm9KalLxj2PPbLh6f8A4djG8Y', choices=[Choice(finish_reason='stop', index=0, message=ChatCompletionMessage(content='No hay un "mejor" lenguaje de programación para aprender, ya que depende de tus intereses, objetivos y el tipo de desarrollo que te interese. Algunos lenguajes populares para empezar a aprender a programar incluyen Python, JavaScript, Java, C# y Ruby. Estos lenguajes son conocidos por su sintaxis clara y su versatilidad, lo que los hace buenos candidatos para principiantes. También es útil investigar qué lenguajes son populares en la industria en la que te gustaría trabajar, ya que el conocimiento de un lenguaje en demanda puede abrirte más oportunidades laborales. En resumen, la elección del lenguaje de programación para aprender dependerá de tus preferencias personales y de tus metas profesionales.', role='assistant', function_call=None, tool_calls=None))], created=1701584994, model='gpt-3.5-turbo-1106', object='chat.completion', system_fingerprint='fp_eeff13170a', usage=CompletionUsage(completion_tokens=181, prompt_tokens=21, total_tokens=202)))
	

	

		
print(f"response.id = {response.id}")
print(f"response.choices = {response.choices}")
for i in range(len(response.choices)):
    print(f"response.choices[{i}] = {response.choices[i]}")
    print(f"\tresponse.choices[{i}].finish_reason = {response.choices[i].finish_reason}")
    print(f"\tresponse.choices[{i}].index = {response.choices[i].index}")
    print(f"\tresponse.choices[{i}].message = {response.choices[i].message}")
    content = response.choices[i].message.content.replace('

', '
		')
    print(f"		response.choices[{i}].message.content = 
		{content}")
    print(f"		response.choices[{i}].message.role = {response.choices[i].message.role}")
    print(f"		response.choices[{i}].message.function_call = {response.choices[i].message.function_call}")
    print(f"		response.choices[{i}].message.tool_calls = {response.choices[i].message.tool_calls}")
print(f"response.created = {response.created}")
print(f"response.model = {response.model}")
print(f"response.object = {response.object}")
print(f"response.system_fingerprint = {response.system_fingerprint}")
print(f"response.usage = {response.usage}")
print(f"\tresponse.usage.completion_tokens = {response.usage.completion_tokens}")
print(f"\tresponse.usage.prompt_tokens = {response.usage.prompt_tokens}")
print(f"\tresponse.usage.total_tokens = {response.usage.total_tokens}")
	
	

		
	

	

		
response.id = chatcmpl-8RaHCm9KalLxj2PPbLh6f8A4djG8Y
response.choices = [Choice(finish_reason='stop', index=0, message=ChatCompletionMessage(content='No hay un "mejor" lenguaje de programación para aprender, ya que depende de tus intereses, objetivos y el tipo de desarrollo que te interese. Algunos lenguajes populares para empezar a aprender a programar incluyen Python, JavaScript, Java, C# y Ruby. Estos lenguajes son conocidos por su sintaxis clara y su versatilidad, lo que los hace buenos candidatos para principiantes. También es útil investigar qué lenguajes son populares en la industria en la que te gustaría trabajar, ya que el conocimiento de un lenguaje en demanda puede abrirte más oportunidades laborales. En resumen, la elección del lenguaje de programación para aprender dependerá de tus preferencias personales y de tus metas profesionales.', role='assistant', function_call=None, tool_calls=None))]
response.choices[0] = Choice(finish_reason='stop', index=0, message=ChatCompletionMessage(content='No hay un "mejor" lenguaje de programación para aprender, ya que depende de tus intereses, objetivos y el tipo de desarrollo que te interese. Algunos lenguajes populares para empezar a aprender a programar incluyen Python, JavaScript, Java, C# y Ruby. Estos lenguajes son conocidos por su sintaxis clara y su versatilidad, lo que los hace buenos candidatos para principiantes. También es útil investigar qué lenguajes son populares en la industria en la que te gustaría trabajar, ya que el conocimiento de un lenguaje en demanda puede abrirte más oportunidades laborales. En resumen, la elección del lenguaje de programación para aprender dependerá de tus preferencias personales y de tus metas profesionales.', role='assistant', function_call=None, tool_calls=None))
	response.choices[0].finish_reason = stop
	response.choices[0].index = 0
	response.choices[0].message = ChatCompletionMessage(content='No hay un "mejor" lenguaje de programación para aprender, ya que depende de tus intereses, objetivos y el tipo de desarrollo que te interese. Algunos lenguajes populares para empezar a aprender a programar incluyen Python, JavaScript, Java, C# y Ruby. Estos lenguajes son conocidos por su sintaxis clara y su versatilidad, lo que los hace buenos candidatos para principiantes. También es útil investigar qué lenguajes son populares en la industria en la que te gustaría trabajar, ya que el conocimiento de un lenguaje en demanda puede abrirte más oportunidades laborales. En resumen, la elección del lenguaje de programación para aprender dependerá de tus preferencias personales y de tus metas profesionales.', role='assistant', function_call=None, tool_calls=None)
		response.choices[0].message.content = 
		No hay un "mejor" lenguaje de programación para aprender, ya que depende de tus intereses, objetivos y el tipo de desarrollo que te interese. Algunos lenguajes populares para empezar a aprender a programar incluyen Python, JavaScript, Java, C# y Ruby. Estos lenguajes son conocidos por su sintaxis clara y su versatilidad, lo que los hace buenos candidatos para principiantes. También es útil investigar qué lenguajes son populares en la industria en la que te gustaría trabajar, ya que el conocimiento de un lenguaje en demanda puede abrirte más oportunidades laborales. En resumen, la elección del lenguaje de programación para aprender dependerá de tus preferencias personales y de tus metas profesionales.
		response.choices[0].message.role = assistant
		response.choices[0].message.function_call = None
		response.choices[0].message.tool_calls = None
response.created = 1701584994
response.model = gpt-3.5-turbo-1106
response.object = chat.completion
response.system_fingerprint = fp_eeff13170a
response.usage = CompletionUsage(completion_tokens=181, prompt_tokens=21, total_tokens=202)
	response.usage.completion_tokens = 181
	response.usage.prompt_tokens = 21
	response.usage.total_tokens = 202
	

	

		
promtp = "Hola, soy MaximoFN, ¿Cómo estás?"
response = client.chat.completions.create(
  model=model,
  messages=[{"role": "user", "content": f"{promtp}"}],
)
content = response.choices[0].message.content.replace('

', '
		')
print(content)
	
	

		
	

	

		
Hola MaximoFN, soy un modelo de inteligencia artificial diseñado para conversar y ayudar en lo que necesites. ¿En qué puedo ayudarte hoy?
	

	

		
promtp = "¿Me puedes decir cómo me llamo?"
response = client.chat.completions.create(
  model=model,
  messages=[{"role": "user", "content": f"{promtp}"}],
)
content = response.choices[0].message.content.replace('

', '
		')
print(content)
	
	

		
	

	

		
Lo siento, no tengo esa información. Pero puedes decírmelo tú.
	

	

		
promtp = "¿Me puedes decir cómo me llamo?"
response = client.chat.completions.create(
  model=model,
  messages=[
      {"role": "user", "content": "Hola, soy MaximoFN, ¿Cómo estás?"},
      {"role": "assistant", "content": "Hola MaximoFN, soy un modelo de inteligencia artificial diseñado para conversar y ayudar en lo que necesites. ¿En qué puedo ayudarte hoy?"},
      {"role": "user", "content": f"{promtp}"},
  ],
)
content = response.choices[0].message.content.replace('

', '
		')
print(content)
	
	

		
	

	

		
Tu nombre es MaximoFN.
	

	

		
promtp = "¿Cómo puedo listar los archivos de un directorio en la terminal?"
response = client.chat.completions.create(
  model=model,
  messages=[{"role": "user", "content": f"{promtp}"}],
)
content = response.choices[0].message.content.replace('

', '
		')
print(content)
	
	

		
	

	

		
En la terminal de un sistema operativo Unix o Linux, puedes listar los archivos de un directorio utilizando el comando `ls`. Por ejemplo, si quieres listar los archivos del directorio actual, simplemente escribe `ls` y presiona Enter. Si deseas listar los archivos de un directorio específico, puedes proporcionar la ruta del directorio después del comando `ls`, por ejemplo `ls /ruta/del/directorio`. Si deseas ver más detalles sobre los archivos, puedes usar la opción `-l` para obtener una lista detallada o `-a` para mostrar también los archivos ocultos.
	

	

		
promtp = "¿Cómo puedo listar los archivos de un directorio en la terminal?"
response = client.chat.completions.create(
  model=model,
  messages=[
      {"role": "user", "content": "Obtener las 10 primeras líneas de un archivo"},
      {"role": "assistant", "content": "head -n 10"},
      {"role": "user", "content": "Encontrar todos los archivos con extensión .txt"},
      {"role": "assistant", "content": "find . -name '*.txt"},
      {"role": "user", "content": "Dividir un archivo en varias páginas"},
      {"role": "assistant", "content": "split -l 1000"},
      {"role": "user", "content": "Buscar la dirección IP 12.34.56.78"},
      {"role": "assistant", "content": "nslookup 12.34.56.78"},
      {"role": "user", "content": "Obtener las 5 últimas líneas de foo.txt"},
      {"role": "assistant", "content": "tail -n 5 foo.txt"},
      {"role": "user", "content": "Convertir ejemplo.png en JPEG"},
      {"role": "assistant", "content": "convert example.png example.jpg"},
      {"role": "user", "content": "Create a git branch named 'new-feature"},
      {"role": "assistant", "content": "git branch new-feature"},
      {"role": "user", "content": f"{promtp}"},
  ],
)
content = response.choices[0].message.content.replace('

', '
		')
print(content)
	
	

		
	

	

		
Puede usar el comando `ls` en la terminal para listar los archivos de un directorio. Por ejemplo:
```
ls
```
Muestra los archivos y directorios en el directorio actual.
	

	

		
promtp = "¿Cómo puedo listar los archivos de un directorio en la terminal?"
response = client.chat.completions.create(
  model=model,
  messages=[
      {"role": "system", "content": "Eres un experto asistente de terminal de ubuntu que responde solo con comandos de terminal"},
      {"role": "user", "content": f"{promtp}"},
  ],
)
content = response.choices[0].message.content.replace('

', '
		')
print(content)
	
	

		
	

	

		
Puedes listar los archivos de un directorio en la terminal usando el comando `ls`. Por ejemplo, para listar los archivos del directorio actual, simplemente escribe `ls` y presiona Enter. Si quieres listar los archivos de un directorio específico, puedes utilizar `ls` seguido de la ruta del directorio. Por ejemplo, `ls /ruta/del/directorio`.
	

	

		
promtp = "¿Cómo puedo listar los archivos de un directorio en la terminal?"
response = client.chat.completions.create(
  model=model,
  messages=[
      {"role": "system", "content": "Eres un experto asistente de terminal de ubuntu que responde solo con comandos de terminal"},
      {"role": "user", "content": "Obtener las 10 primeras líneas de un archivo"},
      {"role": "assistant", "content": "head -n 10"},
      {"role": "user", "content": "Encontrar todos los archivos con extensión .txt"},
      {"role": "assistant", "content": "find . -name '*.txt"},
      {"role": "user", "content": "Dividir un archivo en varias páginas"},
      {"role": "assistant", "content": "split -l 1000"},
      {"role": "user", "content": "Buscar la dirección IP 12.34.56.78"},
      {"role": "assistant", "content": "nslookup 12.34.56.78"},
      {"role": "user", "content": "Obtener las 5 últimas líneas de foo.txt"},
      {"role": "assistant", "content": "tail -n 5 foo.txt"},
      {"role": "user", "content": "Convertir ejemplo.png en JPEG"},
      {"role": "assistant", "content": "convert example.png example.jpg"},
      {"role": "user", "content": "Create a git branch named 'new-feature"},
      {"role": "assistant", "content": "git branch new-feature"},
      {"role": "user", "content": f"{promtp}"},
  ],
)
content = response.choices[0].message.content.replace('

', '
		')
print(content)
	
	

		
	

	

		
Puedes listar los archivos de un directorio en la terminal utilizando el comando "ls". Por ejemplo, para listar los archivos en el directorio actual, puedes ejecutar el comando "ls". Si deseas listar los archivos de otro directorio, simplemente especifica el directorio después del comando "ls", por ejemplo "ls /ruta/al/directorio".
	

	

		
promtp = "¿Cuál es el mejor lenguaje de programación para aprender?"
response = client.chat.completions.create(
  model = model,
  messages = [{"role": "user", "content": f"{promtp}"}],
  max_tokens = 50,
)
content = response.choices[0].message.content.replace('

', '
		')
print(content)
print(f"\nresponse.choices[{i}].finish_reason = {response.choices[i].finish_reason}")
	
	

		
	

	

		
La respuesta a esta pregunta puede variar dependiendo de los intereses y objetivos individuales, ya que cada lenguaje de programación tiene sus propias ventajas y desventajas. Sin embargo, algunos de los lenguajes más
response.choices[0].finish_reason = length
	

	

		
promtp = "¿Cuál es el mejor lenguaje de programación para aprender?"
temperature = 0
response = client.chat.completions.create(
  model = model,
  messages = [{"role": "user", "content": f"{promtp}"}],
  temperature = temperature,
)
content_0 = response.choices[0].message.content.replace('

', '
		')
print(content_0)
	
	

		
	

	

		
No hay un "mejor" lenguaje de programación para aprender, ya que la elección depende de los intereses y objetivos individuales. Algunos lenguajes populares para principiantes incluyen Python, JavaScript, Java y C#. Cada uno tiene sus propias ventajas y desventajas, por lo que es importante investigar y considerar qué tipo de desarrollo de software te interesa antes de elegir un lenguaje para aprender.
	

	

		
promtp = "¿Cuál es el mejor lenguaje de programación para aprender?"
temperature = 1
response = client.chat.completions.create(
  model = model,
  messages = [{"role": "user", "content": f"{promtp}"}],
  temperature = temperature,
)
content_1 = response.choices[0].message.content.replace('

', '
		')
print(content_1)
	
	

		
	

	

		
No hay un "mejor" lenguaje de programación para aprender, ya que la elección depende de los objetivos y preferencias individuales del programador. Sin embargo, algunos lenguajes populares para principiantes incluyen Python, JavaScript, Java y C++. Estos lenguajes son relativamente fáciles de aprender y tienen una amplia gama de aplicaciones en la industria de la tecnología. Es importante considerar qué tipo de proyectos o campos de interés te gustaría explorar al momento de elegir un lenguaje de programación para aprender.
	

	

		
print(content_0)
print(content_1)
	
	

		
	

	

		
No hay un "mejor" lenguaje de programación para aprender, ya que la elección depende de los intereses y objetivos individuales. Algunos lenguajes populares para principiantes incluyen Python, JavaScript, Java y C#. Cada uno tiene sus propias ventajas y desventajas, por lo que es importante investigar y considerar qué tipo de desarrollo de software te interesa antes de elegir un lenguaje para aprender.
No hay un "mejor" lenguaje de programación para aprender, ya que la elección depende de los objetivos y preferencias individuales del programador. Sin embargo, algunos lenguajes populares para principiantes incluyen Python, JavaScript, Java y C++. Estos lenguajes son relativamente fáciles de aprender y tienen una amplia gama de aplicaciones en la industria de la tecnología. Es importante considerar qué tipo de proyectos o campos de interés te gustaría explorar al momento de elegir un lenguaje de programación para aprender.
	

	

		
promtp = "¿Cuál es el mejor lenguaje de programación para aprender?"
top_p = 0
response = client.chat.completions.create(
  model = model,
  messages = [{"role": "user", "content": f"{promtp}"}],
  top_p = top_p,
)
content_0 = response.choices[0].message.content.replace('

', '
		')
print(content_0)
	
	

		
	

	

		
No hay un "mejor" lenguaje de programación para aprender, ya que la elección depende de los intereses y objetivos individuales. Algunos lenguajes populares para principiantes incluyen Python, JavaScript, Java y C#. Cada uno tiene sus propias ventajas y desventajas, por lo que es importante investigar y considerar qué tipo de desarrollo de software te interesa antes de elegir un lenguaje para aprender.
	

	

		
promtp = "¿Cuál es el mejor lenguaje de programación para aprender?"
top_p = 1
response = client.chat.completions.create(
  model = model,
  messages = [{"role": "user", "content": f"{promtp}"}],
  top_p = top_p,
)
content_1 = response.choices[0].message.content.replace('

', '
		')
print(content_1)
	
	

		
	

	

		
El mejor lenguaje de programación para aprender depende de los objetivos del aprendizaje y del tipo de programación que se quiera realizar. Algunos lenguajes de programación populares para principiantes incluyen Python, Java, JavaScript y Ruby. Sin embargo, cada lenguaje tiene sus propias ventajas y desventajas, por lo que es importante considerar qué tipo de proyectos o aplicaciones se quieren desarrollar antes de elegir un lenguaje de programación para aprender. Python es a menudo recomendado por su facilidad de uso y versatilidad, mientras que JavaScript es ideal para la programación web.
	

	

		
print(content_0)
print(content_1)
	
	

		
	

	

		
No hay un "mejor" lenguaje de programación para aprender, ya que la elección depende de los intereses y objetivos individuales. Algunos lenguajes populares para principiantes incluyen Python, JavaScript, Java y C#. Cada uno tiene sus propias ventajas y desventajas, por lo que es importante investigar y considerar qué tipo de desarrollo de software te interesa antes de elegir un lenguaje para aprender.
El mejor lenguaje de programación para aprender depende de los objetivos del aprendizaje y del tipo de programación que se quiera realizar. Algunos lenguajes de programación populares para principiantes incluyen Python, Java, JavaScript y Ruby. Sin embargo, cada lenguaje tiene sus propias ventajas y desventajas, por lo que es importante considerar qué tipo de proyectos o aplicaciones se quieren desarrollar antes de elegir un lenguaje de programación para aprender. Python es a menudo recomendado por su facilidad de uso y versatilidad, mientras que JavaScript es ideal para la programación web.
	

	

		
promtp = "¿Cuál es el mejor lenguaje de programación para aprender?"
temperature = 1
top_p = 1
response = client.chat.completions.create(
  model = model,
  messages = [{"role": "user", "content": f"{promtp}"}],
  temperature = temperature,
  top_p = top_p,
  n = 4
)
content_0 = response.choices[0].message.content.replace('

', '
		')
content_1 = response.choices[1].message.content.replace('

', '
		')
content_2 = response.choices[2].message.content.replace('

', '
		')
content_3 = response.choices[3].message.content.replace('

', '
		')
print(content_0)
print(content_1)
print(content_2)
print(content_3)
	
	

		
	

	

		
El mejor lenguaje de programación para aprender depende de tus objetivos y del tipo de aplicaciones que te interese desarrollar. Algunos de los lenguajes más populares para aprender son:
		1. Python: Es un lenguaje de programación versátil, fácil de aprender y con una amplia comunidad de desarrolladores. Es ideal para principiantes y se utiliza en una gran variedad de aplicaciones, desde desarrollo web hasta inteligencia artificial.
		2. JavaScript: Es el lenguaje de programación más utilizado en el desarrollo web. Es imprescindible para aquellos que quieren trabajar en el ámbito del desarrollo frontend y backend.
		3. Java: Es un lenguaje de programación muy popular en el ámbito empresarial, por lo que aprender Java puede abrirte muchas puertas laborales. Además, es un lenguaje estructurado que te enseñará conceptos importantes de la programación orientada a objetos.
		4. C#: Es un lenguaje de programación desarrollado por Microsoft que se utiliza especialmente en el desarrollo de aplicaciones para Windows. Es ideal para aquellos que quieran enfocarse en el desarrollo de aplicaciones de escritorio.
		En resumen, el mejor lenguaje de programación para aprender depende de tus intereses y objetivos personales. Es importante investigar y considerar qué tipos de aplicaciones te gustaría desarrollar para elegir el lenguaje que más se adapte a tus necesidades.
El mejor lenguaje de programación para aprender depende de los objetivos y necesidades individuales. Algunos de los lenguajes de programación más populares y ampliamente utilizados incluyen Python, JavaScript, Java, C++, Ruby y muchos otros. Python es a menudo recomendado para principiantes debido a su sintaxis simple y legible, mientras que JavaScript es esencial para el desarrollo web. Java es ampliamente utilizado en el desarrollo de aplicaciones empresariales y Android, y C++ es comúnmente utilizado en sistemas embebidos y juegos. En última instancia, el mejor lenguaje de programación para aprender dependerá de lo que quiera lograr con su habilidades de programación.
El mejor lenguaje de programación para aprender depende de los intereses y objetivos individuales de cada persona. Algunos de los lenguajes más populares y bien documentados para principiantes incluyen Python, JavaScript, Java y C#. Python es conocido por su simplicidad y versatilidad, mientras que JavaScript es esencial para el desarrollo web. Java y C# son lenguajes ampliamente utilizados en la industria y proporcionan una base sólida para aprender otros lenguajes. En última instancia, la elección del lenguaje dependerá de las metas personales y la aplicación deseada.
El mejor lenguaje de programación para aprender depende de los intereses y objetivos de cada persona. Algunos lenguajes populares para principiantes incluyen Python, Java, JavaScript, C++ y Ruby. Python es frecuentemente recomendado para aprender a programar debido a su sintaxis sencilla y legible, mientras que Java es utilizado en aplicaciones empresariales y Android. JavaScript es fundamental para el desarrollo web, y C++ es comúnmente utilizado en aplicaciones de alto rendimiento. Ruby es conocido por su facilidad de uso y flexibilidad. En última instancia, la elección del lenguaje dependerá de qué tipo de desarrollo te interesa y qué tipo de proyectos deseas realizar.
	

{
          "mensagens":
          [
              {
                  "role": "system", "content": "Marv é um chatbot factual que também é sarcástico".
              },
              {
                  "role": "user", "content": "What's the capital of France?" (Qual é a capital da França?)
              },
              {
                  "role": "assistant", "content": "Paris, como se todo mundo já não soubesse disso".
              }
      
      }
      {
          "mensagens":
          [
              {
                  "role": "system", "content": "Marv é um chatbot factual que também é sarcástico".
              },
              {
                  "role": "user", "content": "Who wrote 'Romeo and Juliet'?" (Quem escreveu 'Romeu e Julieta'?)
              },
              {
                  "role": "assistant", "content": "Oh, apenas um cara chamado William Shakespeare. Já ouviu falar dele?"
              }
      
      }
      {
          "mensagens":
          [
              {
                  "role": "system", "content": "Marv é um chatbot factual que também é sarcástico".
              },
              {
                  "role": "user", "content": "How far is the Moon from Earth?" (A que distância a Lua está da Terra?)
              },
              {
                  "role": "assistant", "content": "Cerca de 384.400 quilômetros. Mais ou menos alguns, como se isso realmente importasse".
              }
      
      }
      

csv
      prompt,conclusão
      O que o curso Introduction to Python aborda no material fornecido? "O curso Introduction to Python aborda tópicos como tipos de dados, operadores, uso de funções e classes, manipulação de objetos iteráveis e uso de módulos. [Mais informações] (https://maximofn.com/python/)"
      Quais são os tipos de dados básicos em Python, "Python tem 7 tipos de dados básicos: texto (`str`), numérico (`int`, `float`, `complex`), sequências (`list`, `tuple`, `range`), mapeamento (`dict`), conjuntos (`set`, `frozenset`), booleano (`bool`) e binário (`bytes`, `bytearray`, `memoryview`). [Mais informações] (https://maximofn.com/python/)"
      O que são operadores em Python e como eles são usados, "Operadores em Python são símbolos especiais usados para realizar operações como adição, subtração, multiplicação e divisão entre variáveis e valores. Eles também incluem operadores lógicos para comparações. [Mais informações] (https://maximofn.com/python/)"
      Como uma função é definida e usada em Python, "Em Python, uma função é definida com a palavra-chave `def`, seguida do nome da função e de parênteses. As funções podem ter parâmetros e valores de retorno. Elas são usadas para encapsular a lógica que pode ser reutilizada em todo o código. [Mais informações] (https://maximofn.com/python/)"
      O que são classes Python e como elas são usadas?, "As classes Python são a base da programação orientada a objetos. Elas permitem que você crie objetos que encapsulam dados e funcionalidades. As classes são definidas com a palavra-chave `class`, seguida pelo nome da classe. [Mais informações] (https://maximofn.com/python/)"
      ...

	

		
import os
      
      CSVs_path = "openai/faqs_posts"
      percetn_train = 0.8
      percetn_validation = 0.2
      
      jsonl_train = os.path.join(CSVs_path, "train.jsonl")
      jsonl_validation = os.path.join(CSVs_path, "validation.jsonl")
      
      # Create the train.jsonl and validation.jsonl files
      with open(jsonl_train, 'w') as f:
          f.write('')
      with open(jsonl_validation, 'w') as f:
          f.write('')
      
      for file in os.listdir(CSVs_path): # Get all files in the directory
          if file.endswith(".csv"): # Check if file is a csv
              csv = os.path.join(CSVs_path, file) # Get the path to the csv file
              number_of_lines = 0
              csv_content = []
              for line in open(csv, 'r'): # Read all lines in the csv file
                  if line.startswith('prompt'): # Skip the first line
                      continue
                  number_of_lines += 1 # Count the number of lines
                  csv_content.append(line) # Add the line to the csv_content list
      
              number_of_train = int(number_of_lines * percetn_train) # Calculate the number of lines for the train.jsonl file
              number_of_validation = int(number_of_lines * percetn_validation) # Calculate the number of lines for the validation.sjonl file
      
              for i in range(number_of_lines):
                  prompt = csv_content[i].split(',')[0]
                  response = ','.join(csv_content[i].split(',')[1:]).replace('
', '').replace('"', '')
                  if i > 0 and i <= number_of_train:
                      # add line to train.jsonl
                      with open(jsonl_train, 'a') as f:
                          f.write(f'{"{"}"messages": [{"{"}"role": "system", "content": "Eres un amable asistente dispuesto a responder."{"}"}, {"{"}"role": "user", "content": "{prompt}"{"}"}, {"{"}"role": "assistant", "content": "{response}"{"}"}]{"}"}
')
                  elif i > number_of_train and i <= number_of_train + number_of_validation:
                      # add line to validation.csv
                      with open(jsonl_validation, 'a') as f:
                          f.write(f'{"{"}"messages": [{"{"}"role": "system", "content": "Eres un amable asistente dispuesto a responder."{"}"}, {"{"}"role": "user", "content": "{prompt}"{"}"}, {"{"}"role": "assistant", "content": "{response}"{"}"}]{"}"}
')
	
	

		
	

	

		
import os
CSVs_path = "openai/faqs_posts"
percetn_train = 0.8
percetn_validation = 0.2
jsonl_train = os.path.join(CSVs_path, "train.jsonl")
jsonl_validation = os.path.join(CSVs_path, "validation.jsonl")
# Create the train.jsonl and validation.jsonl files
with open(jsonl_train, 'w') as f:
    f.write('')
with open(jsonl_validation, 'w') as f:
    f.write('')
for file in os.listdir(CSVs_path): # Get all files in the directory
    if file.endswith(".csv"): # Check if file is a csv
        csv = os.path.join(CSVs_path, file) # Get the path to the csv file
        number_of_lines = 0
        csv_content = []
        for line in open(csv, 'r'): # Read all lines in the csv file
            if line.startswith('prompt'): # Skip the first line
                continue
            number_of_lines += 1 # Count the number of lines
            csv_content.append(line) # Add the line to the csv_content list
        number_of_train = int(number_of_lines * percetn_train) # Calculate the number of lines for the train.jsonl file
        number_of_validation = int(number_of_lines * percetn_validation) # Calculate the number of lines for the validation.sjonl file
        for i in range(number_of_lines):
            prompt = csv_content[i].split(',')[0]
            response = ','.join(csv_content[i].split(',')[1:]).replace('\n', '').replace('"', '')
            if i > 0 and i <= number_of_train:
                # add line to train.jsonl
                with open(jsonl_train, 'a') as f:
                    f.write(f'{"{"}"messages": [{"{"}"role": "system", "content": "Eres un amable asistente dispuesto a responder."{"}"}, {"{"}"role": "user", "content": "{prompt}"{"}"}, {"{"}"role": "assistant", "content": "{response}"{"}"}]{"}"}\n')
            elif i > number_of_train and i <= number_of_train + number_of_validation:
                # add line to validation.csv
                with open(jsonl_validation, 'a') as f:
                    f.write(f'{"{"}"messages": [{"{"}"role": "system", "content": "Eres un amable asistente dispuesto a responder."{"}"}, {"{"}"role": "user", "content": "{prompt}"{"}"}, {"{"}"role": "assistant", "content": "{response}"{"}"}]{"}"}\n')
from collections import defaultdict
import json
# Format error checks
format_errors = defaultdict(int)
with open(jsonl_train, 'r', encoding='utf-8') as f:
    dataset = [json.loads(line) for line in f]
for ex in dataset:
    if not isinstance(ex, dict):
        format_errors["data_type"] += 1
        continue
        
    messages = ex.get("messages", None)
    if not messages:
        format_errors["missing_messages_list"] += 1
        continue
        
    for message in messages:
        if "role" not in message or "content" not in message:
            format_errors["message_missing_key"] += 1
        
        if any(k not in ("role", "content", "name", "function_call") for k in message):
            format_errors["message_unrecognized_key"] += 1
        
        if message.get("role", None) not in ("system", "user", "assistant", "function"):
            format_errors["unrecognized_role"] += 1
            
        content = message.get("content", None)
        function_call = message.get("function_call", None)
        
        if (not content and not function_call) or not isinstance(content, str):
            format_errors["missing_content"] += 1
    
    if not any(message.get("role", None) == "assistant" for message in messages):
        format_errors["example_missing_assistant_message"] += 1
if format_errors:
    print("Found errors:")
    for k, v in format_errors.items():
        print(f"{k}: {v}")
else:
    print("No errors found")
	
	

		
	

	

		
No errors found
	

	

		
# Format error checks
format_errors = defaultdict(int)
with open(jsonl_validation, 'r', encoding='utf-8') as f:
    dataset = [json.loads(line) for line in f]
for ex in dataset:
    if not isinstance(ex, dict):
        format_errors["data_type"] += 1
        continue
        
    messages = ex.get("messages", None)
    if not messages:
        format_errors["missing_messages_list"] += 1
        continue
        
    for message in messages:
        if "role" not in message or "content" not in message:
            format_errors["message_missing_key"] += 1
        
        if any(k not in ("role", "content", "name", "function_call") for k in message):
            format_errors["message_unrecognized_key"] += 1
        
        if message.get("role", None) not in ("system", "user", "assistant", "function"):
            format_errors["unrecognized_role"] += 1
            
        content = message.get("content", None)
        function_call = message.get("function_call", None)
        
        if (not content and not function_call) or not isinstance(content, str):
            format_errors["missing_content"] += 1
    
    if not any(message.get("role", None) == "assistant" for message in messages):
        format_errors["example_missing_assistant_message"] += 1
if format_errors:
    print("Found errors:")
    for k, v in format_errors.items():
        print(f"{k}: {v}")
else:
    print("No errors found")
	
	

		
	

	

		
No errors found
	

pip install tiktoken
      

	

		
import tiktoken
      import numpy as np
      
      encoding = tiktoken.get_encoding("cl100k_base")
      
      def num_tokens_from_messages(messages, tokens_per_message=3, tokens_per_name=1):
          num_tokens = 0
          for message in messages:
              num_tokens += tokens_per_message
              for key, value in message.items():
                  num_tokens += len(encoding.encode(value))
                  if key == "name":
                      num_tokens += tokens_per_name
          num_tokens += 3
          return num_tokens
      
      def num_assistant_tokens_from_messages(messages):
          num_tokens = 0
          for message in messages:
              if message["role"] == "assistant":
                  num_tokens += len(encoding.encode(message["content"]))
          return num_tokens
      
      def print_distribution(values, name):
          print(f"
#### Distribution of {name}:")
          print(f"min:{min(values)}, max: {max(values)}")
          print(f"mean: {np.mean(values)}, median: {np.median(values)}")
          print(f"p5: {np.quantile(values, 0.1)}, p95: {np.quantile(values, 0.9)}")
	
	

		
	

	

		
import tiktoken
import numpy as np
encoding = tiktoken.get_encoding("cl100k_base")
def num_tokens_from_messages(messages, tokens_per_message=3, tokens_per_name=1):
    num_tokens = 0
    for message in messages:
        num_tokens += tokens_per_message
        for key, value in message.items():
            num_tokens += len(encoding.encode(value))
            if key == "name":
                num_tokens += tokens_per_name
    num_tokens += 3
    return num_tokens
def num_assistant_tokens_from_messages(messages):
    num_tokens = 0
    for message in messages:
        if message["role"] == "assistant":
            num_tokens += len(encoding.encode(message["content"]))
    return num_tokens
def print_distribution(values, name):
    print(f"\n#### Distribution of {name}:")
    print(f"min:{min(values)}, max: {max(values)}")
    print(f"mean: {np.mean(values)}, median: {np.median(values)}")
    print(f"p5: {np.quantile(values, 0.1)}, p95: {np.quantile(values, 0.9)}")
# Warnings and tokens counts
n_missing_system = 0
n_missing_user = 0
n_messages = []
convo_lens = []
assistant_message_lens = []
with open(jsonl_train, 'r', encoding='utf-8') as f:
    dataset = [json.loads(line) for line in f]
for ex in dataset:
    messages = ex["messages"]
    if not any(message["role"] == "system" for message in messages):
        n_missing_system += 1
    if not any(message["role"] == "user" for message in messages):
        n_missing_user += 1
    n_messages.append(len(messages))
    convo_lens.append(num_tokens_from_messages(messages))
    assistant_message_lens.append(num_assistant_tokens_from_messages(messages))
    
print("Num examples missing system message:", n_missing_system)
print("Num examples missing user message:", n_missing_user)
print_distribution(n_messages, "num_messages_per_example")
print_distribution(convo_lens, "num_total_tokens_per_example")
print_distribution(assistant_message_lens, "num_assistant_tokens_per_example")
n_too_long = sum(l > 4096 for l in convo_lens)
print(f"\n{n_too_long} examples may be over the 4096 token limit, they will be truncated during fine-tuning")
	
	

		
	

	

		
Num examples missing system message: 0
Num examples missing user message: 0
#### Distribution of num_messages_per_example:
min:3, max: 3
mean: 3.0, median: 3.0
p5: 3.0, p95: 3.0
#### Distribution of num_total_tokens_per_example:
min:67, max: 132
mean: 90.13793103448276, median: 90.0
p5: 81.5, p95: 99.5
#### Distribution of num_assistant_tokens_per_example:
min:33, max: 90
mean: 48.66379310344828, median: 48.5
p5: 41.0, p95: 55.5
0 examples may be over the 4096 token limit, they will be truncated during fine-tuning
	

	

		
# Warnings and tokens counts
n_missing_system = 0
n_missing_user = 0
n_messages = []
convo_lens = []
assistant_message_lens = []
with open(jsonl_validation, 'r', encoding='utf-8') as f:
    dataset = [json.loads(line) for line in f]
for ex in dataset:
    messages = ex["messages"]
    if not any(message["role"] == "system" for message in messages):
        n_missing_system += 1
    if not any(message["role"] == "user" for message in messages):
        n_missing_user += 1
    n_messages.append(len(messages))
    convo_lens.append(num_tokens_from_messages(messages))
    assistant_message_lens.append(num_assistant_tokens_from_messages(messages))
    
print("Num examples missing system message:", n_missing_system)
print("Num examples missing user message:", n_missing_user)
print_distribution(n_messages, "num_messages_per_example")
print_distribution(convo_lens, "num_total_tokens_per_example")
print_distribution(assistant_message_lens, "num_assistant_tokens_per_example")
n_too_long = sum(l > 4096 for l in convo_lens)
print(f"\n{n_too_long} examples may be over the 4096 token limit, they will be truncated during fine-tuning")
	
	

		
	

	

		
Num examples missing system message: 0
Num examples missing user message: 0
#### Distribution of num_messages_per_example:
min:3, max: 3
mean: 3.0, median: 3.0
p5: 3.0, p95: 3.0
#### Distribution of num_total_tokens_per_example:
min:80, max: 102
mean: 89.93333333333334, median: 91.0
p5: 82.2, p95: 96.8
#### Distribution of num_assistant_tokens_per_example:
min:41, max: 57
mean: 48.2, median: 49.0
p5: 42.8, p95: 51.6
0 examples may be over the 4096 token limit, they will be truncated during fine-tuning
	

	

		
# Pricing and default n_epochs estimate
MAX_TOKENS_PER_EXAMPLE = 4096
TARGET_EPOCHS = 3
MIN_TARGET_EXAMPLES = 100
MAX_TARGET_EXAMPLES = 25000
MIN_DEFAULT_EPOCHS = 1
MAX_DEFAULT_EPOCHS = 25
with open(jsonl_train, 'r', encoding='utf-8') as f:
    dataset = [json.loads(line) for line in f]
convo_lens = []
for ex in dataset:
    messages = ex["messages"]
    convo_lens.append(num_tokens_from_messages(messages))
n_epochs = TARGET_EPOCHS
n_train_examples = len(dataset)
if n_train_examples * TARGET_EPOCHS < MIN_TARGET_EXAMPLES:
    n_epochs = min(MAX_DEFAULT_EPOCHS, MIN_TARGET_EXAMPLES // n_train_examples)
elif n_train_examples * TARGET_EPOCHS > MAX_TARGET_EXAMPLES:
    n_epochs = max(MIN_DEFAULT_EPOCHS, MAX_TARGET_EXAMPLES // n_train_examples)
n_billing_tokens_in_dataset = sum(min(MAX_TOKENS_PER_EXAMPLE, length) for length in convo_lens)
print(f"Dataset has ~{n_billing_tokens_in_dataset} tokens that will be charged for during training")
print(f"By default, you'll train for {n_epochs} epochs on this dataset")
print(f"By default, you'll be charged for ~{n_epochs * n_billing_tokens_in_dataset} tokens")
tokens_for_train = n_epochs * n_billing_tokens_in_dataset
	
	

		
	

	

		
Dataset has ~10456 tokens that will be charged for during training
By default, you'll train for 3 epochs on this dataset
By default, you'll be charged for ~31368 tokens
	

	

		
pricing = 0.0080
num_tokens_pricing = 1000
training_price = pricing * (tokens_for_train // num_tokens_pricing)
print(f"Training price: ${training_price}")
	
	

		
	

	

		
Training price: $0.248
	

	

		
# Pricing and default n_epochs estimate
MAX_TOKENS_PER_EXAMPLE = 4096
TARGET_EPOCHS = 3
MIN_TARGET_EXAMPLES = 100
MAX_TARGET_EXAMPLES = 25000
MIN_DEFAULT_EPOCHS = 1
MAX_DEFAULT_EPOCHS = 25
with open(jsonl_validation, 'r', encoding='utf-8') as f:
    dataset = [json.loads(line) for line in f]
convo_lens = []
for ex in dataset:
    messages = ex["messages"]
    convo_lens.append(num_tokens_from_messages(messages))
n_epochs = TARGET_EPOCHS
n_train_examples = len(dataset)
if n_train_examples * TARGET_EPOCHS < MIN_TARGET_EXAMPLES:
    n_epochs = min(MAX_DEFAULT_EPOCHS, MIN_TARGET_EXAMPLES // n_train_examples)
elif n_train_examples * TARGET_EPOCHS > MAX_TARGET_EXAMPLES:
    n_epochs = max(MIN_DEFAULT_EPOCHS, MAX_TARGET_EXAMPLES // n_train_examples)
n_billing_tokens_in_dataset = sum(min(MAX_TOKENS_PER_EXAMPLE, length) for length in convo_lens)
print(f"Dataset has ~{n_billing_tokens_in_dataset} tokens that will be charged for during training")
print(f"By default, you'll train for {n_epochs} epochs on this dataset")
print(f"By default, you'll be charged for ~{n_epochs * n_billing_tokens_in_dataset} tokens")
tokens_for_validation = n_epochs * n_billing_tokens_in_dataset
	
	

		
	

	

		
Dataset has ~1349 tokens that will be charged for during training
By default, you'll train for 6 epochs on this dataset
By default, you'll be charged for ~8094 tokens
	

	

		
validation_price = pricing * (tokens_for_validation // num_tokens_pricing)
print(f"Validation price: ${validation_price}")
	
	

		
	

	

		
Validation price: $0.064
	

	

		
total_price = training_price + validation_price
print(f"Total price: ${total_price}")
	
	

		
	

	

		
Total price: $0.312
	

	

		
result = client.files.create(file=open(jsonl_train, "rb"), purpose="fine-tune")
	
	

		
	

	

		
result = client.files.create(file=open(jsonl_train, "rb"), purpose="fine-tune")
type(result), result
	
	

		
	

	

		
(openai.types.file_object.FileObject,
 FileObject(id='file-LWztOVasq4E0U67wRe8ShjLZ', bytes=47947, created_at=1701585709, filename='train.jsonl', object='file', purpose='fine-tune', status='processed', status_details=None))
	

	

		
print(f"result.id = {result.id}")
print(f"result.bytes = {result.bytes}")
print(f"result.created_at = {result.created_at}")
print(f"result.filename = {result.filename}")
print(f"result.object = {result.object}")
print(f"result.purpose = {result.purpose}")
print(f"result.status = {result.status}")
print(f"result.status_details = {result.status_details}")
	
	

		
	

	

		
result.id = file-LWztOVasq4E0U67wRe8ShjLZ
result.bytes = 47947
result.created_at = 1701585709
result.filename = train.jsonl
result.object = file
result.purpose = fine-tune
result.status = processed
result.status_details = None
	

	

		
jsonl_train_id = result.id
print(f"jsonl_train_id = {jsonl_train_id}")
	
	

		
	

	

		
jsonl_train_id = file-LWztOVasq4E0U67wRe8ShjLZ
	

	

		
result = client.files.create(file=open(jsonl_validation, "rb"), purpose="fine-tune")
	
	

		
	

	

		
result = client.files.create(file=open(jsonl_validation, "rb"), purpose="fine-tune")
print(f"result.id = {result.id}")
print(f"result.bytes = {result.bytes}")
print(f"result.created_at = {result.created_at}")
print(f"result.filename = {result.filename}")
print(f"result.object = {result.object}")
print(f"result.purpose = {result.purpose}")
print(f"result.status = {result.status}")
print(f"result.status_details = {result.status_details}")
	
	

		
	

	

		
result.id = file-E0YOgIIe9mwxmFcza5bFyVKW
result.bytes = 6369
result.created_at = 1701585730
result.filename = validation.jsonl
result.object = file
result.purpose = fine-tune
result.status = processed
result.status_details = None
	

	

		
jsonl_validation_id = result.id
print(f"jsonl_train_id = {jsonl_validation_id}")
	
	

		
	

	

		
jsonl_train_id = file-E0YOgIIe9mwxmFcza5bFyVKW
	

	

		
result = client.fine_tuning.jobs.create(model = "gpt-3.5-turbo", training_file = jsonl_train_id, validation_file = jsonl_validation_id)
	
	

		
	

	

		
result = client.fine_tuning.jobs.create(model = "gpt-3.5-turbo", training_file = jsonl_train_id, validation_file = jsonl_validation_id)
type(result), result
	
	

		
	

	

		
(openai.types.fine_tuning.fine_tuning_job.FineTuningJob,
 FineTuningJob(id='ftjob-aBndcorOfQLP0UijlY0R4pTB', created_at=1701585758, error=None, fine_tuned_model=None, finished_at=None, hyperparameters=Hyperparameters(n_epochs='auto', batch_size='auto', learning_rate_multiplier='auto'), model='gpt-3.5-turbo-0613', object='fine_tuning.job', organization_id='org-qDHVqEZ9tqE2XuA0IgWi7Erg', result_files=[], status='validating_files', trained_tokens=None, training_file='file-LWztOVasq4E0U67wRe8ShjLZ', validation_file='file-E0YOgIIe9mwxmFcza5bFyVKW'))
	

	

		
print(f"result.id = {result.id}")
print(f"result.created_at = {result.created_at}")
print(f"result.error = {result.error}")
print(f"result.fine_tuned_model = {result.fine_tuned_model}")
print(f"result.finished_at = {result.finished_at}")
print(f"result.hyperparameters = {result.hyperparameters}")
print(f"\tn_epochs = {result.hyperparameters.n_epochs}")
print(f"\tbatch_size = {result.hyperparameters.batch_size}")
print(f"\tlearning_rate_multiplier = {result.hyperparameters.learning_rate_multiplier}")
print(f"result.model = {result.model}")
print(f"result.object = {result.object}")
print(f"result.organization_id = {result.organization_id}")
print(f"result.result_files = {result.result_files}")
print(f"result.status = {result.status}")
print(f"result.trained_tokens = {result.trained_tokens}")
print(f"result.training_file = {result.training_file}")
print(f"result.validation_file = {result.validation_file}")
	
	

		
	

	

		
result.id = ftjob-aBndcorOfQLP0UijlY0R4pTB
result.created_at = 1701585758
result.error = None
result.fine_tuned_model = None
result.finished_at = None
result.hyperparameters = Hyperparameters(n_epochs='auto', batch_size='auto', learning_rate_multiplier='auto')
	n_epochs = auto
	batch_size = auto
	learning_rate_multiplier = auto
result.model = gpt-3.5-turbo-0613
result.object = fine_tuning.job
result.organization_id = org-qDHVqEZ9tqE2XuA0IgWi7Erg
result.result_files = []
result.status = validating_files
result.trained_tokens = None
result.training_file = file-LWztOVasq4E0U67wRe8ShjLZ
result.validation_file = file-E0YOgIIe9mwxmFcza5bFyVKW
	

	

		
fine_tune_id = result.id
print(f"fine_tune_id = {fine_tune_id}")
	
	

		
	

	

		
fine_tune_id = ftjob-aBndcorOfQLP0UijlY0R4pTB
	

	

		
result = client.fine_tuning.jobs.retrieve(fine_tuning_job_id = fine_tune_id)
	
	

		
	

	

		
result = client.fine_tuning.jobs.retrieve(fine_tuning_job_id = fine_tune_id)
type(result), result