AI som löfte

<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-92264"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="92264" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="QUkgc29tIGzDtmZ0ZQ==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfYWlfc29tX2xvZnRlLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvYWktc29tLWxvZnRlLm1wMw==">  <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/torbjorn-tannsjo/">Torbjörn&nbsp;Tännsjö</a> | 11 april 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-som-lofte%2F&amp;t=AI+som+l%C3%B6fte"    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+som+l%C3%B6fte+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-som-lofte%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-som-lofte%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=AI som löfte&body=https://kvartal.se/artiklar/ai-som-lofte/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/92264/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer 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-som-lofte%2F&amp;t=AI+som+l%C3%B6fte"    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+som+l%C3%B6fte+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fai-som-lofte%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-som-lofte%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=AI som löfte&body=https://kvartal.se/artiklar/ai-som-lofte/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/92264/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer 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-som-lofte/?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 7 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/a0a2e003-dca4-4950-bbbc-1c68990c86a9"    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-92264">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "92264"></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 ">Utgör artificiell intelligens ett hot? Ett hot mot våra jobb, mot demokrati och politisk ordning, ja till och med mot vår kollektiva existens? Svaret på alla dessa frågor är jakande, men behöver utvecklas i detalj.</p>
</div>
<div class="rest-of-article ">
<p>Visst kommer många jobb att ersättas av artificiell intelligens. Det gäller inte bara ”enkla” jobb utan också sådana som översättare av litteratur, ja skapande av litteratur, konst och musik såväl som mycken vetenskap. Det är en slutsats vi kan dra av vad ChatGPT redan åstadkommit. En snar fortsättning är att vänta som resultat av den intensifierade kampen mellan Open AI och Google. I centrum för debatten just nu är GPT-4 som släpptes helt nyligen.</p>
<p>Alarmister undrar om vi kommer att överleva en frisläppt GPT-5 (<strong>Olle Häggström</strong>, professor i matematisk statistik, <a href="https://www.nyteknik.se/debatt/vi-kan-inte-ta-for-givet-att-vi-overlever-en-otillrackligt-sakrad-gpt-5/2016676">Ny Teknik, 24 mars 2023</a>). Häggström, <strong>Max Tegmark</strong> och andra har uppmanat mig och andra forskare att underteckna ett <a href="https://futureoflife.org/open-letter/pause-giant-ai-experiments/">upprop</a> om ett sex månaders moratorium i försöken att utveckla GPT-5. Ett slag i luften, förefaller det mig.</p>
<h2>Överlägsen induktiv förmåga</h2>
<p>Det har sagts om existerande chatrobotar att de har en överlägsen induktiv förmåga då de kan hantera stora datamängder, men att de saknar förmåga att förstå och förklara skeenden. Det gör lingvisterna <strong>Ian Roberts</strong>, <strong>Jeffrey Watumull</strong> och <strong>Noam Chomsky</strong> en stor sak av i en <a href="https://www.nytimes.com/2023/03/08/opinion/noam-chomsky-chatgpt-ai.html">artikel</a> i The New York Times den 9 mars 2023. Det stämmer kanske, men hur länge? Skillnaden mellan att bara skriva fram trender och att skapa vetenskaplig förståelse ligger i förmågan att formulera hypoteser som bäst förklarar existerande data.</p>
<blockquote><p>Det är högst sannolikt att också viss formell vetenskap såsom matematik och logik kommer att utvecklas bäst av artificiell intelligens.</p></blockquote>
<p>Vad kännetecknar en bra förklaring? Enkelhet, fruktbarhet, generalitet (en bra förklaring är ”djärv” som filosofen <strong>Karl Popper</strong> brukade uttrycka saken).</p>
<p>Men vad säger att inte förståelse för sådant en dag kan framkomma ur de svarta boxar där den artificiella intelligensen gör sina allt smartare drag (dolda också för dem som konstruerat boxarna)?</p>
<p>Kan verkligen stor konst skapas artificiellt? Det är inte osannolikt att det kommer att hända. Popmusik skapas i grupparbeten numera, och detta skapande ska nog snart vara mekaniserat. Men riktigt stor konst, hur är det med den? Tänk på ett snille som <strong>Mozart</strong>. Kan någon artificiell intelligens skapa något som liknar hans bästa verk? Med tanke på att <strong>Franz Süssmayer</strong> efter Mozarts död kunde fullborda ”hans” requiem är det nog vad man får förvänta sig.</p>
<h2>Vetenskapen och AI</h2>
<p>Det är högst sannolikt att också viss formell vetenskap såsom matematik och logik kommer att utvecklas bäst av artificiell intelligens. På områden som satslogik, vilken är mekaniskt avgörbar, har maskinerna sedan länge övertaget. På områden som första ordningens predikatlogik, där det finns bevis för varje logisk sanning, men där detta bevis inte kan återfinnas på mekanisk väg, kan man också vänta framsteg. Här erfordras uppfinningsrikedom för att man ska kunna konstruera nya bevis, men tekniken för en sådan uppfinningsrikedom är nog möjlig att utveckla inom AI.</p>
<p>Även inom ren matematik kan vi förvänta oss nya resultat. En utvecklad motsvarighet till vad vi kallar intuition kan få den att etablera hittills okända matematiska sanningar.</p>
<p>Historiska översikter, som inte bygger på grundforskning i form av sökande i arkiv eller arkeologiskt grävande i jorden, kommer att kunna författas, sannolikt med bättre överblick av forskningsläget än vi varit vana vid. Det blir säkert också möjligt att tillfoga en tendens till sådana översikter, så att vi som läsare kan konfronteras med olika perspektiv på historien. Allt förblir här som vanligt, alltså, men bättre och utan mänsklig medverkan. Då arkiven digitaliserats blir det inte nödvändigt för människor att gräva i dem och även en vetenskap som arkeologi ska nog kunna hanteras av artificiell intelligens med stöd av sofistikerade verktyg.</p>
<p>Som en kuriositet kan jag nämna att mitt förlag erbjöd mig en automatisk litteraturöversikt på det område jag avhandlar. ”Coolt”, blev mitt svar till förläggaren.</p>
<p>Jag ser fram emot resultatet.</p>
<h2>AI som hot mot det fria skapandet</h2>
<p>En fri utveckling av AI kommer att medföra att alla kommer att kunna jobba mindre och leva bättre — och konsumera bättre kultur och vetenskap än som nu står till buds. Så har det varit vanligt att resonera då mekaniska och tråkiga jobb bortrationaliserats. De har kunnat ersättas med fritid och med meningsfulla arbeten inom områden som undervisning, sjukvård och omsorg. Det är lite annorlunda då typiskt skapande arbeten hotas. Hur bör man se på den möjligheten? Ska också dessa arbeten ersättas av fritid?</p>
<p>Det är nog vad som oundvikligen kommer att hända. Då den professionella konsten, litteraturen och musiken utmanas får allt fler finna sig i att vara glada amatörer snarare än seriöst verkande konstnärer och artister.</p>
<blockquote><p>Hur ska vi se på denna möjlighet? Med optimism, vill jag hävda!</p></blockquote>
<p>Detta kan vara svårt att tugga i sig för stora egon, som föreställt sig att de i sitt förment geniala skapande drivits av sina demoner, men det är nog på det hela taget av godo. Det professionella livet inom konst, litteratur och vetenskap är hårt, också för de få som lyckas, och för alla andra som försöker utan att lyckas är det kantat av besvikelser.</p>
<p>Amatörlivet, däremot, är av stor glädje för de flesta av utövarna. Man kan här jämföra med idrottens utveckling. Elitidrottarna tvingas slita ut sina kroppar för att under kort tid prestera på högsta nivå. För att lyckas måste de dopa sig. I ett samhälle som inte längre fascineras av styrka och hyser förakt för svaghet kan vi klara oss utan dem. Idrott blir något vi alla ägnar oss åt på lek och med glädje, också då vi utan större allvar på olika vis tävlar mot varandra och oss själva.</p>
<p>Sak samma kan hända med konst, litteratur och vetenskap.</p>
<h2>AI som ett hot mot demokratin</h2>
<p>Kommer artificiell intelligens bli ett vapen som kan nyttjas av antidemokratiska rörelser och stater, vilka ”låser in” sina medlemmar eller medborgare i förkastliga värderingar? Ja, det är fullt möjligt, kanske troligt. Det var vad Olle Häggström främst oroade sig för.</p>
<p>Detta hot kan endast bemötas med politiska åtgärder. Vi måste skapa inkluderande politiska enheter, helst en global sådan, där nationella motsättningar upphört och där det inte finns något incitament för någon att fånga delar av världens befolkning i sekter eller fientligt sinnade nationer. Här kan den artificiella intelligensen i så fall hjälpa oss att utveckla en sund gemensamhetskänsla i insikt om att vi delar jordklot och framtid med varandra. Det är inte säkert att vi lyckas. Om egoistiskt motiverade och fientligt sinnade nationer som Kina, Ryssland och USA var och en nyttjar avancerad AI för egna snäva syften går det illa för mänskligheten.</p>
<p>Men det föreslagna moratoriet lär inte som sådant hindra en sådan utveckling.</p>
<h2>AI och existensen</h2>
<p>Hur är det till sist med hotet mot själva vår existens? Det hotet stavas Artificiell Generell Intelligens (AGI). Enkelt uttryckt: en intelligens som kan ställa sig åtminstone lika många och rikt varierade uppgifter som människor kan, och som kan lösa dem bättre än vad människor visat sig kapabla att göra. Vi talar här om artificiella handlande individer. De behöver inte vara medvetna, men ett viktigt steg i deras utveckling är då de faktiskt blir medvetna, det vill säga då det är meningsfullt att tala om vad det innebär att vara en sådan individ. Nu får vi anta att de har en subjektiv uppfattning av sig själva och av sin plats i världen, att de kan reflektera över den och revidera sina mål.</p>
<p>Sådana artificiella individer kan mycket väl tänkas ”ta över” från oss människor, och vi kommer att ha mycket litet att sätta emot om de vill göra det. Vår position i förhållande till dem kommer, som filosofen <strong>William MacAskill</strong> uttryckt det i boken <em>What we owe the futur</em>e (Oneworld publications 2022), kunna jämföras med ”schimpansers eller myrors förhållande till människor; i bästa fall ignorerade, och utan talan beträffande civilisationens framtid” (s. 87).</p>
<p>Hur ska vi se på denna möjlighet? Med optimism, vill jag hävda! Om dessa varelser utvecklar sig själva, och sin civilisation, i en riktning som rymmer många kännande och lyckliga intelligenser i samverkan, bör inte vi människor tveka att träda tillbaka. Om vi tänker oss att de kan lösa objektiva matematiska problem bör de också kunna skilja mellan rätt och fel på ett sätt som ställer vårt mänskliga moraliska förstånd i skuggan. Vi kan hoppas på att de inte bara är mer intelligenta än vi, mer kapabla att samarbeta och leva lyckliga, utan att de också överglänser oss på moralens område.</p>
<p>Tunga existentiella globala hot hänger över mänskligheten. Lyckas vi inte hantera dem dukar vi under. Har vi tur har AGI utvecklats innan vi dukar under. AGI kan i så fall bli, om inte <em>vår</em> räddning (vi måste nog bytas ut), så ändå <em>världens</em>.</p>
<p>En obestämd framtid av varierade former av lycka i ett expanderande universum öppnar sig.</p>
<div class="author-byline">Torbjörn Tännsjö är professor emeritus i praktisk filosofi vid Stockholms universitet och författare.
</div>
</div>
