AI har börjat förfalska kunskap

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">      Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-94067"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="94067" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9haV9oYXJfYm9yamF0X2ZvcmZhbHNrYV9rdW5za2FwLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvYWktaGFyLWJvcmphdC1mb3JmYWxza2Eta3Vuc2thcC5tcDM=">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/hakan-lindgren/">Håkan&nbsp;Lindgren</a> | 2 maj 2023<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-har-borjat-forfalska-kunskap%2F&amp;t=AI+har+b%C3%B6rjat+f%C3%B6rfalska+kunskap"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=AI+har+b%C3%B6rjat+f%C3%B6rfalska+kunskap+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-har-borjat-forfalska-kunskap%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-har-borjat-forfalska-kunskap%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=AI har börjat förfalska kunskap&body=https://kvartal.se/artiklar/ai-har-borjat-forfalska-kunskap/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/94067/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/94067/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="kv-art-ext-sep"></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-har-borjat-forfalska-kunskap%2F&amp;t=AI+har+b%C3%B6rjat+f%C3%B6rfalska+kunskap"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=AI+har+b%C3%B6rjat+f%C3%B6rfalska+kunskap+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-har-borjat-forfalska-kunskap%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-har-borjat-forfalska-kunskap%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=AI har börjat förfalska kunskap&body=https://kvartal.se/artiklar/ai-har-borjat-forfalska-kunskap/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/94067/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/94067/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/ai-har-borjat-forfalska-kunskap/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 11 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/94067"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-94067">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "94067"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Ännu 2023 kan våra tidningsredaktörer sätta 1950-talsrubriker som ”Är robotar farliga?” när de får en AI-kritisk text (<a href="https://www.expressen.se/kultur/ide/ai-forskare-tror-att-tekniken-kan-doda-oss/">Expressen, pappersupplagan 11/4 2023</a>). Verkligheten ser lite annorlunda ut. Det har kollegorna på The Guardian fått lära sig.</p>
</div>
<div class="rest-of-article ">
<p>De har börjat få mail där läsare frågar efter artiklar de inte lyckas hitta på nätet. Vid närmare efterforskning kan Guardian-redaktionen inte heller hitta artiklarna i sina interna arkiv. Det som hänt, <a href="https://www.theguardian.com/commentisfree/2023/apr/06/ai-chatgpt-guardian-technology-risks-fake-article">förklarar</a> tidningens innovationsredaktör <strong>Chris Moran</strong>, är att människor har börjat använda sig av ChatGPT för att göra research. När de ställer en fråga svarar ChatGPT ibland med citat från tidningstexter som inte finns.</p>
<p>Programmet har nämligen börjat förfalska källtexter. De fejkade tidningsartiklarna är signerade med verkliga Guardian-journalisters namn, och förfalskningarna blir extra trovärdiga eftersom texterna handlar om de ämnen som dessa journalister vanligtvis brukar skriva om.</p>
<h2>All digital information</h2>
<p>Ta ett ögonblicks paus och fundera över hur stort det här kommer att kunna bli. Det handlar inte bara om tidningstexter, utan om all digital information. I en amerikansk studie, skriver Moran, tog 89 procent av eleverna hjälp av ChatGPT för att göra sina läxor. Föreställ dig också de proportioner det kommer att handla om.</p>
<p>Hur många tusen fiktiva tidningstexter hinner ChatGPT spamma världen med innan en mänsklig journalist har skrivit dagens första artikel?</p>
<p>Om studenter börjar använda den här typen av system för att söka uppgifter och skriva sina uppsatser – vad återstår i så fall av en skola eller ett universitet? Kommer det fortfarande att vara relevant att bedriva undervisning i framtiden? I vilken form? Sådana frågor är vi nu tvungna att komma tillrätta med, bara för att några personer har velat tjäna en slant på den senaste teknologiska hypen.</p>
<p>Här är ytterligare ett exempel på den falska information som ChatGPT har börjat uppfinna på egen hand; jag hoppas att det kan ge näring åt läsarens fantasi. En amerikansk jurist bad nyligen ChatGPT att gå ut på nätet och söka efter akademiker som hade begått sexuella övergrepp. Programmet svarade med en lista där verkliga förövare blandades med oskyldigt anklagade. <strong>Jonathan Turley</strong>, som är professor i juridik vid George Washington University i Washington, <a href="https://www.washingtonpost.com/technology/2023/04/05/chatgpt-lies/">påstods ha förgripit sig</a> på sina studenter under en resa till Alaska som aldrig har ägt rum.</p>
<blockquote><p>Vi har inte skapat ett användbart researchverktyg, vi har skapat ett program som genererar fejkad och otillförlitlig information.</p></blockquote>
<p>Som källa hänvisade ChatGPT till en artikel i The Washington Post från 2018 – en artikel som aldrig har publicerats, eftersom programmet har skrivit den själv.</p>
<p>Det finns en viktig slutsats att dra här, och jag vill betona den så eftertryckligt jag kan. Ingenting har gått fel. Det här är inga olycksfall i arbetet. Exemplen från The Guardian och The Washington Post betyder att ChatGPT fungerar exakt enligt specifikationerna. Vi har inte skapat ett användbart researchverktyg, vi har skapat ett program som genererar fejkad och otillförlitlig information.</p>
<h2>Som bensin på brasan</h2>
<p>I en konfliktfylld värld som redan har problem med alternativa fakta och fake news fungerar den här sortens AI-program som bensin på brasan. I sin kommentar skriver Moran att han, trots allt, är entusiastisk över den nya teknikens möjligheter. Han berättar inte vad han kommer att svara om tidningens läsare föredrar att lita på ChatGPT, och börjar tro att The Guardian har censurerat de texter som inte går att hitta på nätet – kanske för att skydda vissa viktiga personer. När misstroendet mot etablerade massmedier är så stort behöver vi inte teknologi som förvärrar förtroendekrisen ännu mer.</p>
<p>Om ChatGPT ljög konsekvent skulle det vara ett mindre problem; ett sådant program skulle kunna betraktas som underhållning. Svårigheten är att fakta blandas med halvsanningar och rena påhitt. Hur vet du om ChatGPT ljuger? Du måste kunna ämnet så bra att du inte har något behov av att fråga ChatGPT – större nytta har vi inte av programmet.</p>
<p>Ett par matematiskt kunniga personer på diskussionssajten Metafilter har testat att ställa matematikfrågor till ChatGPT. Deras resultat är mycket avslöjande. Programmet svarade aldrig ”jag vet inte” – inte ens när de bad det att lösa omöjliga uppgifter. Om programmet hade nöjt sig med att googla eller med att plocka information från Wikipedia, kunde det ha svarat ”det här är ett antal välkända, ännu olösta matematiska problem”. I stället påstår det sig ha löst problemen, och det härmar perfekt den auktoritära tonen i matematiska kursböcker: ”notera att …”, ”antag att …” – ett tonfall som låter förtroendeingivande för alla som inte är specialister.</p>
<p>Ställer man samma matematiska fråga formulerad på två olika sätt kan ChatGPT ge två motsägande svar, eftersom det inte finns något medvetande bakom svaren. Programmet gör inget annat än att producera ett stycke text som, för alla utom för matematiker, låter trovärdig, men texten innehåller ingen information, den bara härmar informationens utseende. En sida med datorgenererad utfyllnad av typen ”Lorem ipsum” hade varit lika meningsfull, men mindre skadlig. Om vi sedan föreställer oss att ett gäng biologer skulle ställa biologiska frågor till ChatGPT, att litteraturvetare ställer frågor om litteraturhistoria, och så vidare, ämne för ämne – vad återstår till sist av programmets användbarhet?</p>
<h2>AI-funktioner i söktjänsten</h2>
<p>Det var meningen att vi skulle få robotar som inte lät mänskliga, men som alltid gav matematiskt korrekta svar; i stället har vi fått något som låter som en vanlig kille på nätet, men man kan inte lita på att det talar sanning om man frågar hur mycket klockan är, kommenterade signaturen Phanx på Metafilter.</p>
<p>Naturligtvis kan man invända att människor inte borde använda ChatGPT på samma sätt som när de tidigare googlade efter information, men det kan snart bli svårt att undvika. Google har börjat bli nervösa över att de håller på att förlora AI-kapplöpningen, och tänker <a href="https://www.theverge.com/2023/4/17/23686108/google-ai-search-tools-magi-chatgpt-bing-samsung-deal">bygga in AI-funktioner i sin söktjänst</a>. Det har länge varit svårt att föreställa sig hur en konkurrent till Google skulle kunna se ut, men nu börjar det klarna.</p>
<p>Microsofts sökmotor Bing ligger före Google när det gäller att skapa en illusion av att du chattar med en maskin, och det gör att Samsung nu överväger att byta standardsökmotor i sina telefoner, från Google till Bing. Googles avtal med Samsung är värt tre miljarder dollar, <a href="https://archive.is/VVoCR">skriver</a> teknikreportern <strong>Nico Grant</strong> i The New York Times (16/4 2023).</p>
<p>En sökning via ChatGPT konsumerar för övrigt tio gånger mer energi än en googlesökning. Om den också gör dig tio gånger dummare – vad har du vunnit då?</p>
<blockquote><p>Från och med nu är digital information inte pålitlig.</p></blockquote>
<p>Det finns redan program som genererar realistiska digitalfoton utifrån valfria instruktioner – som att <strong>Donald Trump</strong> <a href="https://levelup.gitconnected.com/the-fake-arrest-of-donald-trump-a-deepfake-odyssey-db3a6c17eba6">flyr från polisen</a>. Den här typen av förfalskningar, som är så skickliga att de inte kan skiljas från dokumentärt material av verkliga händelser, kallas deepfake. För att visa vad som är möjligt har MIT släppt en video där den dåvarande presidenten <strong>Richard Nixon</strong> <a href="https://news.mit.edu/2020/mit-tackles-misinformation-in-event-of-moon-disaster-0720">förklarar att den första månlandningen har misslyckats och att astronauterna har dött</a>. Deepfake behöver inte bara göras av människor i illvilligt syfte; ett lika obehagligt scenario är att vi får en flod av deepfake som produceras av maskiner utan något syfte alls.</p>
<p>Låt hypekarusellen snurra ett par varv till, och vi skulle även kunna ha program som förfalskar foto och rörlig bild när du söker efter källmaterial. Ställ en fråga om en historisk händelse och du kan få dokumentärfilmer som visar vad som helst – kanske att kinesiska soldater befriar Auschwitz, eller valfri berömd politiker tillsammans med minderåriga prostituerade.</p>
<p>Hur ska du avgöra om materialet är trovärdigt? Det enkla svaret är: det kommer du aldrig mer att kunna göra. Från och med nu är digital information inte pålitlig.</p>
<h2>Motsatsen till informationsålder</h2>
<p>När kommer du att dra slutsatsen att det har blivit meningslöst att söka information på nätet? När andelen falska eller opålitliga svar är 20 procent? 30 procent? Hur mycket behöver AI-systemen pissa i poolen innan du tappar lusten att simma? Och om du ger upp tron på att det är meningsfullt att skaffa kunskap – vad har du själv förvandlats till?</p>
<p>Därmed börjar vi kunna se att det som skulle bli en informationsålder har blivit motsatsen: den teknik vi har utvecklat dränker världen i falsk eller otillförlitlig skräpinformation. Vi har, krasst uttryckt, fått en teknologi som förintar kunskap. Vad ska du göra om du vill ha pålitliga fakta? Du använder varken Google, Bing eller ChatGPT. Du betalar.</p>
<p>Det finns en marknad för professionellt insamlad och analyserad information, men den är osynlig. Om du driver ett storföretag har du inte råd att chansa eller att fråga Siri. När internet var nytt fick alla lära sig att säga ”information wants to be free”, men företagsledarna har alltid vetat att de måste öppna plånboken om de ska få information som är värd något.</p>
<p>Konsultföretag som McKinsey och Oliver Wyman gör i princip samma sak som dagstidningarna gjorde förut: de gör research, skriver rapporter, går till källorna, undersöker hur världen förändras. Skillnaden är att tidningarna gjorde det för hela befolkningen, i syfte att skapa upplysta medborgare, medan konsultfirmorna gör det för eliten. Det som håller på att hända är att större delen av mänskligheten förlorar tillgången till kvalificerad omvärldsbevakning. Det går att föreställa sig en framtid med verifierade fakta för den översta 0,1 procenten, medan resten av mänskligheten lever i en sophög av fake news och maskingenererade halvsanningar. Världen håller på att stängas för oss: om ett par generationer vet människor i värsta fall lika lite om världen som om de var födda i en medeltida by och aldrig hade gått i skolan.</p>
<p>Det som gör att en människa är något fundamentalt annat än en dator är inte att vi är mer intelligenta, utan att vi obesvärat kan handskas med osäker, otillräcklig eller motsägelsefull information. Hjärnan ropar inte SYNTAX ERROR och kraschar om de inkommande signalerna avviker en liten aning från det förväntade – det är skillnaden mellan biologi och människotillverkad elektronik. Vår förmåga att leva med osäker information är nu på väg att utsättas för sin största prövning. Kanske kommer vi att upptäcka att vi trivs med att plaska runt i en soppa av pseudoinformation, även om det innebär att all intellektuell utveckling upphör.</p>
<h2>Inte mer medveten än en spisplatta</h2>
<p>För att motverka det är det dags att titta lite närmare på uttrycket ”artificiell intelligens”, framför allt dess andra halva, ordet ”intelligens”. Genom att börja använda ordet ”intelligens” om helt vanlig programvara suggererar man ett annat ord: den som hör ”artificiell intelligens” kommer att tänka ”artificiellt medvetande”.</p>
<p>Man får det att låta som om våra datorer plötsligt hade vaknat till liv, trots att de inte är mer medvetna än en miniräknare eller en spisplatta. Hypen kring AI handlar om att få människor att tro att de inte möter en maskin – de möter en person.</p>
<p>Varför är det så viktigt? Avsikten är att stänga av människors kritiska tänkande och aktivera våra sociala och emotionella reflexer. Vi ska inte tänka: ”Behöver jag verkligen den här maskinen?” Vi ska fråga oss: ”Vad känner ChatGPT just nu? Vad vill AI:n, och hur ska jag förhålla mig till det?”</p>
<p>När vi försöker leva oss in i maskinens icke-existerande känsloliv har vi redan accepterat att maskinen finns. Vi kommer inte att ställa några besvärliga frågor till företaget som står bakom den. Vi kommer att acceptera den teknologi som erbjuds – och det betyder att vi har blivit lydiga och anpassliga konsumenter. AI-branschen vill inte sälja produkter, de vill sälja en social relation. Det är därför ChatGPT kallar sig själv ”jag” i sina medvetslöst framräknade texter.</p>
<blockquote><p>Vilket slags framtida samhälle skulle vara människovärdigt och önskvärt – och vilken teknologi behöver vi utveckla för att nå dit?</p></blockquote>
<p>Fast vänta nu, är inte AI likadant som alla andra teknikskiften? Jo! Och det är det som är det sorgliga, eftersom samma scenario upprepas gång efter gång, utan att vi någonsin lär oss ett dugg.</p>
<p>Inför varje teknikskifte blir vi intalade att det bara finns en enda sak att tänka, nämligen: ”Hur ska jag anpassa mig?” Vi lär oss aldrig att det rätta svaret är: ”Jag ska inte anpassa mig!” Kommer någon och vill sälja en redan färdigtänkt och färdigförpackad framtid ska jag vägra anpassa mig. Varje gång borde jag fråga mig vad jag egentligen vill ha.</p>
<h2>Vilken framtid vill vi ha?</h2>
<p>I stället för att låsa tänkandet vid ett ja eller nej till en viss bestämd teknologi, i stället för att låsa tänkandet vid den idiotiska föreställningen att utvecklingen är ett linjalrakt järnvägsspår där vi bara kan färdas ”framåt” eller ”bakåt” borde vi inse att människan alltid har varit ett redskapsanvändande djur.</p>
<p>Utan redskap – vare sig det handlar om en pinne att gräva med, lertavlor eller mobiltelefoner – kan människan förmodligen inte vara sig själv. Men alla redskap är inte likvärdiga. Vissa teknologier hjälper oss att utveckla vår egen intelligens och vår kreativitet, andra passiviserar oss, och några är direkt skadliga.</p>
<p>Därför är ”ja eller nej till ChatGPT” inte den diskussion vi borde föra. En relevant diskussion börjar med frågor av en helt annan sort. Vad behöver jag för att bli människa? Vilket slags framtida samhälle skulle vara människovärdigt och önskvärt – och vilken teknologi behöver vi utveckla för att nå dit? Om fler människor börjar ställa sig den sortens frågor kommer ett litet antal AI-kåta personer i Kalifornien och Kina inte längre att ha monopol på att utforma framtiden. Det är hög tid att de får konkurrens från en mängd alternativa framtidsvisioner.</p>
<p>Det sista jag läser innan jag skickar in den här artikeln till Kvartal är att ytterligare en lukrativ marknad har öppnats för AI: <a href="https://arstechnica.com/information-technology/2023/04/gpt-4-will-hunt-for-trends-in-medical-records-thanks-to-microsoft-and-epic/">läkarjournaler och medicinsk information</a>.</p>
<div class="author-byline">Håkan Lindgren är frilansskribent.
</div>
</div>
