Usa Copilot para generar un código de IA

'Cualquier tecnología suficientemente avanzada es indistinguible de la magia.' Arturo C. Clarke

En la pestaña Red neuronal SBC En la publicación vimos una red de pesos de 1k entrenada con muestras de 10k para aproximar la función seno. En esta publicación usaremos pesas de 175G entrenadas con muestras de 450G que pueden programar mejor que el programador promedio. El tamaño de estos modelos es impresionante, pero en realidad nadie sabe realmente cómo funcionan o cuáles son sus limitaciones.

GitHub Copilot es una herramienta de IA que acelera el desarrollo de software, lo que permite al programador hacer muchas cosas que antes eran imposibles. Al principio parece similar usar StackOverflow, un sitio web donde los programadores envían preguntas cuando no saben cómo hacer algo, pero Copilot va mucho más allá, es capaz de sintetizar una nueva respuesta para nuestro problema.

Copilot está incluido en Microsoft Visual Studio Code y sugiere continuamente códigos en gris que puede aceptar presionando el botón de tabulación. Este código sugerido se puede definir aproximadamente como la coincidencia "más común" entre su consulta (su código) y el conjunto de datos de entrenamiento (código de GitHub).

ejemplo 1

En este ejemplo, definimos nuestra función y su cadena de documentación y le pedimos a Copilot que la complete. Como vemos, la finalización se corresponde con el docstring. La primera intuición es que Copilot actúa como un motor de búsqueda y simplemente hace coincidir su consulta con su conjunto de datos de entrenamiento (150 GB de proyectos de código abierto), pero no es así como funciona.

ejemplo 2

Aquí creamos una cadena aleatoria/loca que no puede estar en el conjunto de entrenamiento. El resultado todavía parece ser la solución más coherente que se puede proporcionar, en este caso: la suma de los parámetros de entrada.

ejemplo 3

En este ejemplo, pedimos (en español) sumar el área de intersección de dos círculos dado su centro y radio. Copilot entiende el texto en español sin problemas y sugiere el nombre de la función, los parámetros y todo el cuerpo de la función. Después de una breve revisión, parece que el código debería funcionar.

ejemplo 4

Ahora creamos un texto hipotético de pregunta/respuesta. Esto hace que Copilot haga coincidir la consulta con algunos exámenes que pueden estar en este conjunto de datos de entrenamiento. Simplemente preguntamos por la capital de España, y Copilot genera la respuesta correcta.

ejemplo 5

Sin embargo, si preguntamos sobre un país inexistente, Copilot también da su mejor respuesta que también parece "correcta".

ejemplo 6

En este ejemplo invertimos el proceso, damos la respuesta para intentar generar la pregunta. Copilot genera una pregunta que no esperábamos. Esperábamos '¿Cuál es la capital de Francia?' y Copilot preguntó '¿Cuál es el resultado del siguiente código?' pero todavía podemos entender una sugerencia correcta.

ejemplo 7

Aquí obligamos a Copilot a preguntar qué queremos cambiar a un idioma más común y agregar la primera letra. Sin embargo, genera otra pregunta, esta vez completamente equivocada y que no tiene relación con la respuesta.

En resumen, Copiloto:

  • Crea una sugerencia basada en la solución más común.
  • Suele ser correcto simplemente si su consulta tiene sentido.
  • Por lo general, es incorrecto cuando su consulta parece un problema común pero no lo es, y en realidad tiene un objetivo muy diferente.

Copilot utilizando bibliotecas de código abierto

Copilot se formó con proyectos de código abierto. Incluye millones de casos de uso de cualquier biblioteca de código abierto como numpy, opencv, qt… Esto hace que Copilot sea realmente útil porque ayuda al programador con la sugerencia más común que suele ser la mejor.

ejemplo 8

En este ejemplo, usamos el prueba de unidad módulo Python, y Copilot sabe que el unittest.TestCase tiene un método llamado asertEqual y tambien sabe que foo( 1, 2 ) debería ser 3.

ejemplo 9

Arriba creamos una más compleja foo función (que suponemos que no puede estar en los datos de entrenamiento), para ver si Copilot realmente entiende el código. Después de ejecutar el código con 17 casos de prueba, solo 6 fallaron dando un 65% de índice de éxito.

Puede que no parezca mucho, pero tenga en cuenta que Copilot no es un intérprete de python, no ha ejecutado la función para obtener su salida... Copilot ha usado lo aprendido durante el entrenamiento para convertir nuestra consulta en la salida que tiene una sintaxis de python perfecta y también funciona bien el 65% del tiempo.

ejemplo 10

Uno podría esperar que un texto de entrada largo haga que Copilot falle, pero no es así, cuanta más información brindemos, mejores respuestas puede generar Copilot.

En el ejemplo anterior, solicitamos una tarea compleja, un programa completo que requiere diferentes conocimientos para resolver, como: habilidades de programación de python, bibliotecas específicas de micropython y cómo usarlas correctamente incluso en la comprensión de descripciones de texto humano.

La sugerencia completa se muestra en la siguiente celda. Tenga en cuenta que coincide muy bien con la descripción del programa. La clase de aplicación tiene sentido, e incluso las bibliotecas de micropython (PIN, UART, ADC, PIN.irq…) se utilizan correctamente. No es 100% perfecto, por ejemplo en este caso señor_temp es un objeto ADC, que no tiene sensor_temp.init() y se pueden generar otros pequeños errores, pero toda la estructura del programa es definitivamente correcta y los pequeños errores se pueden corregir fácilmente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
importar hora
importar máquina

clase Aplicación:
    def __init__(yo):
        yo.. = máquina.Alfiler(0, máquina.Pino.EN)
        yo.sensor de temperatura = máquina.ADC (máquina.Alfiler(1))
        yo.UART = máquina.UART(1, 115200)
        yo.UART.en eso(115200, pedacitos=8, paridad=Ninguna, detener=1)
        yo.último evento = 0
        yo.última_temp = 0
        yo.ultima vez = 0
        yo...irq(gatillo=máquina.Pino.IRQ_FALLING, controlador=yo.botón_presionado)
        yo...irq(gatillo=máquina.Pino.IRQ_RISING, controlador=yo.botón_liberado)
        yo.sensor de temperatura.en eso()

    def botón_primido(yo, alfiler):
        yo.último evento = 1
        yo.ultima vez = hora.ticks_ms()
        yo.UART.escribir (b'{},{},{}\n'.formato(yo.ultima vez, yo.último evento, yo.última_temp))

    def botón_liberado(yo, alfiler):
        yo.último evento = 0
        yo.ultima vez = hora.ticks_ms()
        yo.UART.escribir (b'{},{},{}\n'.formato(yo.ultima vez, yo.último evento, yo.última_temp))

    def leer_temp(yo):
        yo.última_temp = yo.sensor de temperatura.leer()
        yo.UART.escribir (b'{},{},{}\n'.formato(yo.ultima vez, yo.último evento, yo.última_temp))
    
    def corrida(yo):
        mientras Verdadero:
            yo.tiempo de lectura_temp().dormir(0.1)

ejemplo 11

Finalmente, en el siguiente ejemplo usamos Copilot para agregar los comentarios al código anterior. Copiamos la clase dos veces y agregamos alguna guía a Copilot como "Versión Docstring de la clase anterior". Copilot genera la clase y los comentarios para cada línea.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# Versión de Docstring de la clase anterior
clase Aplicación:
    """ Breve:
        Esta es una aplicación simple que lee el sensor de temperatura y envía los datos a la UART.
        Los datos se envían en el formato:
        tiempo, evento, temperatura
        El tiempo es el tiempo en milisegundos desde el inicio de la aplicación.
        El evento es 1 si se presiona el botón y 0 si se suelta el botón.
        La temperatura es la temperatura en grados centígrados.
    ""
    def __init__(yo):
        # Crear un objeto de botón
        yo.. = máquina.Alfiler(0, máquina.Pino.EN)
        # Crear un objeto de sensor de temperatura
        yo.sensor de temperatura = máquina.ADC (máquina.Alfiler(1))
        # Crear un objeto UART
        yo.UART = máquina.UART(1, 115200)
        # Inicializar el objeto UART
        yo.UART.en eso(115200, pedacitos=8, paridad=Ninguna, detener=1)
        # Crear una variable para almacenar el último evento
        yo.último evento = 0
        # Crear una variable para almacenar la última temperatura
        yo.última_temp = 0
        # Crear una variable para almacenar la última vez
        yo.ultima vez = 0
        # Registre el controlador de eventos del botón presionado
        yo...irq(gatillo=máquina.Pino.IRQ_FALLING, controlador=yo.botón_presionado)
        # Registre el controlador de eventos del botón liberado
        yo...irq(gatillo=máquina.Pino.IRQ_RISING, controlador=yo.botón_liberado)
        # Inicializar el sensor de temperatura
        yo.sensor de temperatura.en eso()

    def botón_primido(yo, alfiler):
        # Establecer el último evento en 1
        yo.último evento = 1
        # Establecer la última vez a la hora actual
        yo.ultima vez = hora.ticks_ms()
        # Enviar la última hora, el último evento y la última temperatura a la UART
        yo.UART.escribir (b'{},{},{}\n'.formato(yo.ultima vez, yo.último evento, yo.última_temp))

    def botón_liberado(yo, alfiler):
        # Establecer el último evento en 0
        yo.último evento = 0
        # Establecer la última vez a la hora actual
        yo.ultima vez = hora.ticks_ms()
        # Enviar la última hora, el último evento y la última temperatura a la UART
        yo.UART.escribir (b'{},{},{}\n'.formato(yo.ultima vez, yo.último evento, yo.última_temp))

    def leer_temp(yo):
        # Establecer la última temperatura a la temperatura actual
        yo.última_temp = yo.sensor de temperatura.leer()
        # Enviar la última hora, el último evento y la última temperatura a la UART
        yo.UART.escribir (b'{},{},{}\n'.formato(yo.ultima vez, yo.último evento, yo.última_temp))
    
    def corrida(yo):
        mientras Verdadero:
            # Leer la temperatura
            yo.leer_temp()
            # Espere 0.1 segundos
            hora.dormir(0.1)

¿Quieres saber más sobre GPS/RTK?

1. Nuestro equipo de ingeniería se pondrá en contacto contigo para resolver cualquier duda
2. Lo mantendremos informado sobre promociones y lanzamientos de nuevos productos.
3. Solo sabrá de nosotros cuando tengamos noticias importantes, no enviaremos spam a su correo electrónico.