Upoznajte naš tim u San Diegu, Sjedinjene Države, od utorka 22. do četvrtka 25. travnja u XPONENTIAL-u, štand 4700

Ažuriranje (13.): Imamo dosta zaliha svih naših proizvoda, pronađite nas i ovdje i    Kupi

Upoznajte naš tim u San Diegu, Sjedinjene Države, od utorka 22. do četvrtka 25. travnja u XPONENTIAL-u, štand 4700

Koristite Copilot za generiranje AI koda

'Svaka dovoljno napredna tehnologija ne može se razlikovati od magije.' Arthur C. Clarke

u SBC neuronska mreža nakon što smo vidjeli mrežu od 1k utega treniranu s 10k uzoraka za aproksimaciju sinusne funkcije. U ovom postu koristit ćemo utege od 175G trenirane s uzorcima od 450G koji mogu programirati bolje od prosječnog programera. Veličina ovih modela je impresivna, ali zapravo nitko ne zna kako zapravo rade ili koja su im ograničenja.

GitHub Copilot je AI alat koji ubrzava razvoj softvera, dopuštajući programeru da radi mnoge stvari koje su prije bile nemoguće. Isprva se čini sličnim koristiti StackOverflow, web stranicu na koju programeri šalju pitanja kada ne znaju kako nešto učiniti, ali Copilot ide mnogo dalje, može sintetizirati novi odgovor za naš problem.

Copilot je uključen u Microsoft Visual Studio Code i kontinuirano predlaže kodove u sivoj boji koje možete prihvatiti pritiskom na gumb kartice. Ovaj predloženi kod može se grubo definirati kao "najčešće" podudaranje između vašeg upita (vaš kod) i skupa podataka za obuku (GitHub kod).

Primjer 1

U ovom primjeru definiramo našu funkciju i njezin niz dokumenata i tražimo od Copilota da ih dovrši. Kao što vidimo, završetak odgovara nizu dokumenata. Prva intuicija je da Copilot djeluje kao tražilica i jednostavno povezuje vaš upit sa svojim skupom podataka za obuku (150 GB projekata otvorenog koda), ali to nije način na koji funkcionira.

Primjer 2

Ovdje stvaramo neki nasumični/ludi niz koji ne može biti u skupu za obuku. Rezultat i dalje izgleda kao najkoherentnije rješenje koje se može dati, u ovom slučaju: zbroj ulaznih parametara.

Primjer 3

U ovom primjeru tražimo (na španjolskom) da zbrojimo područje presjeka dviju kružnica s obzirom na središte i radijus. Copilot bez problema razumije španjolski tekst i predlaže naziv funkcije, parametre i cijelo tijelo funkcije. Nakon kratkog pregleda čini se da bi kôd trebao raditi.

Primjer 4

Sada stvaramo hipotetski tekst pitanja/odgovora. Zbog toga Copilot spaja upit s nekim ispitima koji mogu biti u ovom skupu podataka za obuku. Jednostavno pitamo za glavni grad Španjolske, a Copilot generira točan odgovor.

Primjer 5

Međutim, ako pitamo o nepostojećoj zemlji, Copilot također daje svoj najbolji odgovor koji također izgleda "točno".

Primjer 6

U ovom primjeru obrćemo proces, dajemo odgovor kako bismo pokušali generirati pitanje. Copilot generira pitanje koje nismo očekivali. Očekivali smo 'Koji je glavni grad Francuske?' a Copilot je upitao 'Što je rezultat sljedećeg koda?' ali ipak možemo razumjeti ispravan prijedlog.

Primjer 7

Ovdje prisiljavamo Copilota da pita o tome što želimo promijeniti u uobičajeniji jezik i dodati prvo slovo. Međutim, generira još jedno pitanje, ovaj put potpuno pogrešno i nema nikakve veze s odgovorom.

Ukratko, kopilot:

  • Izrađuje prijedlog na temelju najčešćeg rješenja.
  • Obično je točan samo ako vaš upit ima smisla.
  • Obično je pogrešno kada vaš upit izgleda kao uobičajeni problem, ali nije, i zapravo ima sasvim drugačiji cilj.

Kopilot korištenjem biblioteka otvorenog koda

Kopilot je obučen s projektima otvorenog koda. Uključuje milijune slučajeva upotrebe bilo koje biblioteke otvorenog koda kao što su numpy, opencv, qt… To čini Copilot stvarno korisnim jer pomaže programeru s najčešćim prijedlozima koji su obično najbolji.

Primjer 8

U ovom primjeru koristimo jedinični test python modul, a Copilot zna da je unittest.TestCase ima metodu pod nazivom assertEqual i također zna da foo( 1, 2 ) treba biti 3.

Primjer 9

Iznad stvaramo složeniji foo funkciju (za koju pretpostavljamo da ne može biti u podacima o obuci), da vidimo razumije li Copilot doista kod. Nakon pokretanja koda sa 17 testnih slučajeva, samo 6 nije uspjelo dajući omjer uspješnosti od 65%.

Možda se ne čini mnogo, ali imajte na umu da Copilot nije Python tumač, nije izvršio funkciju da bi dobio svoj izlaz… Copilot je upotrijebio ono što je naučio tijekom obuke da pretvori naš upit u izlaz koji ima savršenu Python sintaksu i također dobro radi 65% vremena.

Primjer 10

Netko bi mogao očekivati ​​da će dugačak ulazni tekst uzrokovati neuspjeh Copilota, ali nije tako, što više informacija damo, to bolje odgovore copilot može generirati.

U gornjem primjeru tražimo složen zadatak, cjeloviti program koji zahtijeva različito razumijevanje za rješavanje, kao što su: vještine programiranja na pythonu, specifične biblioteke za mikropiton i kako ih ispravno koristiti čak i u ljudskom razumijevanju opisa teksta.

Cijeli savjet prikazan je u sljedećoj ćeliji. Imajte na umu da vrlo dobro odgovara opisu programa. Klasa aplikacije ima smisla, a čak se i micropython biblioteke (PIN, UART, ADC, PIN.irq…) ispravno koriste. Nije 100% savršeno, na primjer u ovom slučaju temp_senor je ADC objekt, koji nema temp_sensor.init() i mogu se generirati druge male pogreške, ali cijela je struktura programa definitivno ispravna i male se pogreške mogu lako popraviti.

 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
uvoz vrijeme
uvoz uređaj

razred primjena:
    def __init__(samouprave):
        samouprave.dugme = uređaj.Pin(0, mašina.bor.U)
        samouprave.senzor_temp = uređaj.ADC (stroj.Pin(1))
        samouprave.uart = uređaj.UART(1, 115200)
        samouprave.uart.u tome(115200, komadići=8, paritet=nijedan, stani=1)
        samouprave.posljednji_događaj = 0
        samouprave.zadnja_temp = 0
        samouprave.posljednji put = 0
        samouprave.dugme.irq(okidač=uređaj.bor.IRQ_FALLING, rukovatelj=samouprave.gumb_pritisnut)
        samouprave.dugme.irq(okidač=uređaj.bor.IRQ_RISING, rukovatelj=samouprave.button_released)
        samouprave.senzor_temp.u tome()

    def gumb_pritisnut(samouprave, pribadača):
        samouprave.posljednji_događaj = 1
        samouprave.posljednji put = vrijeme.ticks_ms()
        samouprave.uart.napisati (b'{},{},{}\n'.format(samouprave.posljednji put, samouprave.posljednji_događaj, samouprave.zadnja_temp))

    def gumb_otpušten(samouprave, pribadača):
        samouprave.posljednji_događaj = 0
        samouprave.posljednji put = vrijeme.ticks_ms()
        samouprave.uart.napisati (b'{},{},{}\n'.format(samouprave.posljednji put, samouprave.posljednji_događaj, samouprave.zadnja_temp))

    def čitanje_temp(samouprave):
        samouprave.zadnja_temp = samouprave.senzor_temp.čitati()
        samouprave.uart.napisati (b'{},{},{}\n'.format(samouprave.posljednji put, samouprave.posljednji_događaj, samouprave.zadnja_temp))
    
    def trčanje(samouprave):
        dok Pravi:
            samouprave.read_temp() vrijeme.spavati(0.1)

Primjer 11

Konačno, u donjem primjeru koristimo Copilot za dodavanje komentara prethodnom kodu. Dvaput kopiramo klasu i dodajemo neki vodič za Copilot poput "Docstring verzija gornje klase". Copilot generira klasu i komentare za svaki redak.

 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
# Docstring verzija gornje klase
razred primjena:
    """ Ukratko:
        Ovo je jednostavna aplikacija koja očitava senzor temperature i šalje podatke UART-u.
        Podaci se šalju u formatu:
        vrijeme, događaj, temp
        Vrijeme je vrijeme u milisekundama od početka aplikacije.
        Događaj je 1 ako se gumb pritisne i 0 ako se gumb otpusti.
        Temp je temperatura u stupnjevima celzijusa.
    "" "
    def __init__(samouprave):
        # Napravite objekt gumba
        samouprave.dugme = uređaj.Pin(0, mašina.bor.U)
        # Napravite objekt senzora temperature
        samouprave.senzor_temp = uređaj.ADC (stroj.Pin(1))
        # Napravite UART objekt
        samouprave.uart = uređaj.UART(1, 115200)
        # Inicijalizirajte UART objekt
        samouprave.uart.u tome(115200, komadići=8, paritet=nijedan, stani=1)
        # Napravite varijablu za pohranu posljednjeg događaja
        samouprave.posljednji_događaj = 0
        # Kreirajte varijablu za pohranu zadnje temperature
        samouprave.zadnja_temp = 0
        # Napravite varijablu za pohranu posljednjeg vremena
        samouprave.posljednji put = 0
        # Registrirajte rukovatelja događajem pritisnutog gumba
        samouprave.dugme.irq(okidač=uređaj.bor.IRQ_FALLING, rukovatelj=samouprave.gumb_pritisnut)
        # Registrirajte rukovatelja događajem otpuštanja gumba
        samouprave.dugme.irq(okidač=uređaj.bor.IRQ_RISING, rukovatelj=samouprave.button_released)
        # Inicijalizirajte senzor temperature
        samouprave.senzor_temp.u tome()

    def gumb_pritisnut(samouprave, pribadača):
        # Postavite posljednji događaj na 1
        samouprave.posljednji_događaj = 1
        # Postavite posljednje vrijeme na trenutno vrijeme
        samouprave.posljednji put = vrijeme.ticks_ms()
        # Pošaljite posljednje vrijeme, posljednji događaj i posljednju temperaturu na UART
        samouprave.uart.napisati (b'{},{},{}\n'.format(samouprave.posljednji put, samouprave.posljednji_događaj, samouprave.zadnja_temp))

    def gumb_otpušten(samouprave, pribadača):
        # Postavite posljednji događaj na 0
        samouprave.posljednji_događaj = 0
        # Postavite posljednje vrijeme na trenutno vrijeme
        samouprave.posljednji put = vrijeme.ticks_ms()
        # Pošaljite posljednje vrijeme, posljednji događaj i posljednju temperaturu na UART
        samouprave.uart.napisati (b'{},{},{}\n'.format(samouprave.posljednji put, samouprave.posljednji_događaj, samouprave.zadnja_temp))

    def čitanje_temp(samouprave):
        # Postavite posljednju temperaturu na trenutnu temperaturu
        samouprave.zadnja_temp = samouprave.senzor_temp.čitati()
        # Pošaljite posljednje vrijeme, posljednji događaj i posljednju temperaturu na UART
        samouprave.uart.napisati (b'{},{},{}\n'.format(samouprave.posljednji put, samouprave.posljednji_događaj, samouprave.zadnja_temp))
    
    def trčanje(samouprave):
        dok Pravi:
            # Očitajte temperaturu
            samouprave.read_temp()
            # Pričekajte 0.1 sekundu
            vrijeme.spavati(0.1)

Ako vam se svidio ovaj sadržaj, možete nas pratiti na Twitter, YouTube, Facebook or LinkedIn da biste bili u tijeku s ovakvim sadržajem.

Želite saznati više o GPS-u/RTK?

1. Naš inženjerski tim će vas kontaktirati kako bismo riješili sva pitanja
2. Obavještavat ćemo vas o promocijama i novim izdanjima proizvoda
3. Javit ćemo vam se samo kada budemo imali važne vijesti, nećemo spamati vašu e-poštu