Microsoft en Github aangeklaagd voor opensourceschending door AI tool

Otto, the inflatable autopilot from the movie “Airplane.”

Programmeur en jurist Matthew Butterick heeft Microsoft en Github aangeklaagd vanwege schendingen van opensourcelicenties, las ik bij Bleeping Computer. De reden is Github’s tool Copilot, een AI code generator die getraind is op de bergen software die op Github gehost worden. De generator blijkt regelmatig lappen tekst uit bestaande werken 1-op-1 aan te leveren, zonder daarbij de juiste licentie + bron te noemen. Hoe zeiden ze dat ook weer, één bron jatten is plagiaat en duizend is inspiratie?

Vorig jaar bracht Github de dienst Copilot uit, een AI-gedreven pair programmer die ontwikkelaars helpt bij het schrijven van code. Copilot stelt contextgebonden code en functies voor, en helpt actief bij het oplossen van problemen door te leren van de code die iemand schrijft. “Trained on billions of lines of public code, GitHub Copilot puts the knowledge you need at your fingertips, saving you time and helping you stay focused.” Het idee is vrij simpel: soms heb je even een klein zetje nodig, een paar regels code om weer verder te kunnen – of om te beseffen, nee dit is precies niet hoe het moet. (Ik experimenteer zelf met Lex.page, die dit doet voor tekstschrijvers, als iemand een invite wil hoor ik het graag.)

Het probleem is natuurlijk: die suggesties moeten ergens vandaan komen. Dat is dus die inspiratie, die patronen die Copilot leert herkennen in honderdduizenden bestanden met source code. Net zoals Lex.page en vele andere tools dat doen met tekst, en DALL-E en consorten met afbeeldingen. Alleen: die hebben een bronbestand dat orde van groottes ruimer is. Alle teksten van heel internet versus alle geprogrammeerde software op Github, dat scheelt nogal een slok op een borrel. Daar komt bij dat er bij software nou eenmaal heel wat minder manieren zijn om iets aan te geven, het moet nou eenmaal technisch aansluiten op het voorgaande.

Het verbaast mij dan ook helemaal niets dat je bij Copilot veel vaker gewoon een lap code uit eerdere software krijgt, “hier, zoals deze het doet”. Dat is helemaal logisch gezien context en dataset, alleen is dat juridisch dus problematisch want een lap broncode in je eigen werk overnemen noemen wij auteursrechtinbreuk tenzij dat mag van de licentie. En aangezien dat dus vaak een opensourcelicentie is, krijg je dan te maken met eisen zoals naamsvermelding of – bij de GPL – het weer moeten open sourcen van je eigen broncode wanneer je dat werk publiceert.

Naar goed Amerikaans gebruik is Butterick dus nu een class action lawsuit begonnen, waar iedereen mag meedoen die ook code op Github heeft staan. Het lastige bij zulke zaken is altijd bewijzen dat jouw werk is overgenomen. Maar specifiek bij dit soort Amerikaanse zaken kan dit interessant worden: als onderdeel van de discovery procedure moet Github op zeker moment onthullen hoe zij aan haar dataset is gekomen. En dan kun je gewoon zien dat jouw code daarin is opgenomen (of niet, maar dat lijkt onwaarschijnlijk).

Arnoud

17 reacties

  1. Zou Butterick ook achter de klanten van Github aan kunnen gaan?

    In de huidige rechtszaak te weten komen welke klanten de Copilot gebruiken en dan van die klanten willen weten bij welke projecten Copilot gebruikt is.

    Kan Butterick vervolgens GPL naleving eisen? Zoals het openbaar maken van het project waar dit in gebruikt is? Als de klanten zeggen dat er geen overeenkomst is en dus geen naleving geëist kan worden, dan wordt de vraag wat het schadebedrag/vergoeding zou moeten zijn. Die is lastig te bepalen, want er is geen geschiedenis van betaald licenseren van deze specifieke stukjes code.

    Het zou niet zo mogen zijn dat men onder de GPL kan wegkomen door te ontkennen dat ze er akkoord mee zijn gegaan, en onder een schadevergoeding wegkomen omdat de code “geen waarde” heeft omdat het nooit verkocht is.

    Al die klanten kunnen vervolgens gaan klagen bij Github / Microsoft dat zij hun dure project open source hebben moeten maken, maar dat is niet Buttericks probleem.

    1. Dat is wel een aardige. Ja, in het Amerikaans rechtssysteem kun je vragen van opgaaf van gebruikers. Lastig is wel dat niet iedereen automatisch jouw code zal hebben gebruikt, dus je hebt daar een bewijshobbel dat de lijst die gebruikers betreft die je rechten schonden. Kom je daar overheen dan kun je ze aanspreken, maar of je dan ook inzage in hun broncode kunt krijgen als deel van de due diligence, ik betwijfel het. Zó makkelijk als “jij gebruikt Copilot, mijn code zit daarin dus jouw code schendt mijn auteursrecht” is het niet.

      Het schade-stuk is makkelijker: als Butterick zijn software bij het Copyright Office heeft gedeponeerd (dat is een eis voor een rechtszaak dus dat zal wel) dan mag hij statutory damages claimen, en dat kan duizenden euro’s per infringing item zijn. Dus los van de werkelijke schade.

      1. Ik vermoed dat het niet geregistreerd was (voor de inbreuk gebeurde), want dat kost rond de 50 dollar per registratie. Hij kan dan nog steeds een rechtszaak starten volgens mij, maar hij kan dan alleen actual damages eisen, wat lastig te bepalen is. Vandaar mijn gedachte dat hij voor naleving van GPL zou willen gaan, geen probleem met schade of registratie.

        Dat registratie een tiental dollar per keer kost is ook een probleem voor veel mensen op Youtube. Als die per video 100 euro aan reclame verdienen, dan willen ze niet daar de helft van kwijt zijn voor registratie.

        1. Goed punt, tenzij hij zou kunnen aantonen dat er ook na registratie nog gebruikers waren die Copilot gebruiken. Dat is zeker mogelijk, Github heeft de tool immers niet teruggetrokken na de dagvaarding.

          Het lastige met naleving is dat je dan aanvaarding van een overeenkomst moet aantonen, wat in de VS ingewikkeld is omdat er geen consideration is bij zo’n enkelzijdige verklaring. De meestbepleite truc is aanklagen voor inbreuk en dan wachten op het verweer “ja maar ho dit mocht van de GPL”, zodat ze zelf erkennen er aan gebonden te zijn. Als de inbreukmaker zegt “ik weet niks van jouw GPL ik was gewoon inbreuk aan het maken” en de rechter zegt “actual damages acht dollar” dan is er verder weinig te halen.

  2. Misschien begrijp ik het niet (dat is goed mogelijk, ik ben geen AI deskundige en ook geen softwareschrijver), maar ik heb toch wel een kanttekening bij ‘alleen is dat juridisch dus problematisch want een lap broncode in je eigen werk overnemen noemen wij auteursrechtinbreuk’

    Ik neem aan dat die lap broncode wordt overgenomen om een welbepaald technisch (tussen)doel te bereiken en omdat vaststaat dat die lap broncode het enige, of toch een van de weinige bekende, technisch middelen is om dat technische doel te bereiken.

    De vraag is dan ook of die lap broncode wel een eigen karakter heeft, niet triviaal is. Je kunt best redenenen dat die lap broncode het natuurlijke logische gevolg is van de technische opdracht in combinatie met de beperkingen van de programmeertaal.

    Om het anders te zeggen: je kunt geen auteursrecht claimen op 1 of 2 regeltjes code, omdat dat een puur technische, niet-creative omzetting van een stappenplan naar code is, maar wel op het uiteindelijke complete werk. Ergens zit daar een grens. En juist de betreffende AI tool rekt de grens tussen waar je nog wel, en niet meer, auteursrecht op kunt claimen, flink op richting steeds grotere stukken.

    1. Het kernwoord is die term ‘lap’, dat betekent meer dan 1 of 2 regeltjes. Inderdaad, een korte instructie die een technische opdracht omzet in iets dat de computer snapt is niet auteursrechtelijk beschermd. Om het scherm te wissen moet je nou eenmaal interrupt 10h aanroepen met AH=0, en er zijn niet bijster veel manieren om dat in een programmeertaal aan te geven. Echter Copilot doet veel meer, zie voorbeeld 2 hier, “schrijf een programma dat boter-kaas-en-eieren kan spelen”. Niet echt wereldschokkende code maar een concreet programma dat dat doet, is auteursrechtelijk echt wel beschermd.

      1. Ik had wel door dat ‘ lap’ meer is dan een paar regels. Mijn argument is dat juist door middel van die AI die onbeschermbare paar regels opgerekt worden tot onbeschermbare hele lappen

        Dat boter-kaas-eieren voorbeeld is juist wel een goed voorbeeld: eens de technische opgave gedefinieerd is, is de uitwerking technische routine, immers: zelfs een machine kan het. Dat het resutaat een kopie is, met onvolkomenheden en al, is dan niet meer relevant: Als het resultaat niets creatiefs is, geldt dan net zo hard voor de kopie als voor het origineel.

        1. Dat boter-kaas-eieren voorbeeld is juist wel een goed voorbeeld: eens de technische opgave gedefinieerd is, is de uitwerking technische routine, immers: zelfs een machine kan het. Dat

          Aan een programmeur vragen boterkaas en eieren te programmeren, is ongeveer net zo specifiek als aan een architect vragen een schuur van 20m^2 te ontwerpen. Je hebt het grote doel, maar er zijn allerlei details waarin je keuzes kan maken. Juist die details maken het onderscheid en bevatten de creativiteit die het auteursrechtelijk beschermd maakt.

          Dat je bij een vraag voor een code die X doet, iemand anders zijn code serveert die X doet, betekend slechts dat je programma een relevant antwoord kan leveren bij de vraag. Maar het zegt niet over het auteursrecht op het geleverde antwoord.

      2. “moet je nou eenmaal interrupt 10h aanroepen met AH=0”

        Wow, wat goed dat er nog mensen zijn die dat weten! MSDOS interrupt calls, of hoe heette dat ook weer. Ik heb ergens een dik boek waar dat allemaal instond.

        Speelt dat in Window nog steeds? In Linux niet, mag ik hopen. Ik doe gewoon ctrl-L, dat is ASCII form feed.

  3. Ik heb naar aanleiding van deze situatie een vraag: Als er broncode met de AGPL licentie gebruikt is voor het trainen van deze tool, zou dat dan betekenen dat de Copilot code en training dataset door iedere Copilot gebruiker op te vragen is? Ik kwalificeer Copilot in ieder geval als “interactieve netwerk service”.

    1. Dat is een hele goede vraag. Deze komt neer op de vraag of de Copilot software en/of de trainingset telt als een “work based on the program” in de zin van de (A)GPL. Ik neig naar nee voor de software, deze verandert immers niet als je er andere trainingsdata in stopt. De werking is wel anders, maar dat is logisch bij het laden van andere invoer. Voor de trainingset neig ik naar “ja”, de AGPL software zit erin en dat is meer dan een “mere aggregation”, een toevallig samenzijn van twee onafhankelijke componenten. Echter, met de trainingset interacteer je niet via een netwerk. Blijft over het van de trainingset afgeleide model, waarmee de Copilot code tot een uitvoer komt. Interacteer je met dat model? Ja, dankzij de software. Net zoals je met een database interacteert door de web frontend. Dus ik denk dat het model onder AGPL vrijgegeven zou moeten worden, en ik vermoed dat de trainingset dan de “complete corresponding source code” daarvan is. Dat gaan ze niet leuk vinden bij Microsoft.

      1. ik vermoed dat de trainingset dan de “complete corresponding source code” daarvan is

        Hmm, ik vind het wel een “aggregation”, immers is niet elk onderdeel van de dataset cruciaal. Het is een “hoe meer hoe beter” verhaal waarbij je zoveel mogelijk op een hoop gooit.

        AGPL artikel 5 zegt: Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.

        Ander dingetje. Die licenties gaan over “source code”. Maar in dit geval wordt de source code niet gezien als source code – om te runnen in een interpreter, of te vertalen naar object code – maar als data. M.a.w. ik vind de AGPL erg gericht op “source code” en “object code” die “runt” of wordt gedistribueerd. AGPL artikel 6 : You may convey a covered work in object code form. Wat hier helemaal niet het geval is.

        1. Ik wil de stelling verdedigen dat het AI model een afgeleid werk is van de data in de trainingsset. In theorie zit alle trainingscode verwoven in het model en het model bepaalt welke suggesties de AI produceert, Codepilot gedraagt zich grotendeels hoe het model voorschrijft. De input code is data voor een data-driven algoritme. Omdat het model zo sterk bepaalt wat Copilot gaat suggereren, kun je het argument maken dat het model onderdeel van de objectcode is. en daarmee zou je volgens de AGPL de trainingsset (=broncode voor het model)) beschikbaar moeten maken.

          Eens dat we tijdens het discussiëren over en schijven van de GPLv3 geen rekening gehouden hebben met dit zeer creatieve gebruik van Open Source code. Maar het geeft ook weer aan hoe complex de implicaties van het Auteursrecht kunnen zijn.

Geef een reactie

Handige HTML: <a href=""> voor hyperlinks, <blockquote> om te citeren, <UL>/<OL> voor lijsten, en <em> en <strong> voor italics en vet.