Att skapa AI genom maskininlärning

Experiment med maskininlärning

Många stora företag har gett sig in på AI; Google byter från Mobile-first till AI-first, media skriver mycket om AI och nya genombrott där exempelvis datorer lär sig spela enkla TV-spel på egen hand genom att testa sig fram. Men vad är egentligen AI och hur fungerar det?

AI och maskininlärning

AI, artificiell intelligens, är ett brett begrepp som innefattar flera områden, bland annat neuronnät, expertsystem och språkbearbetning. I media används det ofta för ett område som kallas maskininlärning där maskiner bygger statistiska modeller av verkligheten genom att gå igenom stora mängder data. Dessa modeller är specialiserade för att lösa ett specifikt problem och inte det som jag personligen skulle kalla ’intelligens’. Det är detta område som jag tänkte skriva om och göra ett litet experiment.

Typer av neurala nätverk

I maskininlärning tränar man ofta olika typer av neurala nätverk för att kunna göra förutsägelser och hitta mönster från sitt data. Vad är då ett neuralt nätverk?

Tidigt i AIs historia försökte man efterhärma den mänskliga hjärnan med celler som kommunicerade med varandra. Detta ledde fram till matematiska modeller där man med matrisalgebra kan beräkna resultatet från indatat genom enkel multiplikation och addition. Problemet består då i hur man beräknar vikterna man multiplicerar med och adderar. Det vanligaste sättet att beräkna det är att börjar med slumpmässiga värden och se hur fel det blir. Felet används sedan för att först ändra vikterna och sedan till slut närma sig en lösning där felet blir tillräckligt litet.

För enkla modeller var detta inget problem. Men när man hade många lager av ’celler’, vilket är ett måste för mer komplicerade modeller, så ökade felet man beräknade med snabbt för varje lager. Det är ett område man kommit inom långt de senaste 10-15 åren och man har möjliggjort det man kallar deep learning. Klassificering av innehåll i bilder är ett av de problem man lyckats bra med tack var utvecklingen av nya metoder.

RNN

RNN, Recurrent Neural Network, är en form av nätverk där man återanvänder tidigare signaler för att dra nytta av sekventiell information. Det kan exempelvis handla om ljudsignaler där man behöver ta hänsyn till flera tidpunkter i data för att se sammanhang eller för ord i meningar; ett ord för sig säger inte så mycket utan sitt sammanhang i meningen. En variant av RNN är LSTM som står för Long Short-Term Memory. Detta nätverk bygger på celler som kan komma ihåg och glömma tidigare tillstånd och har förmågan att hitta samband med ett godtyckligt tidsintervall vilket gjort att det populärt att använda för taligenkänning och språktolkning.

Träning

För att träna upp en modell så krävs mängder med data om man vill få ut något av värde. En del statistiska modeller kan automatiskt separera upp data i olika kluster och se sammanhang och mönster, men för många former av neuronnät krävs att ha data med exempel på input och förväntat resultat. För detta ändamål har det skapats öppet data med samlingar av exempelvis bilder på olika saker med tillhörande etikett för klassificering, och många andra varianter. Ett vanligt förkommande exempel är MNIST, vilket består av handskrivna siffror och som används flitigt i exempelprogram för implementationer.

För att träna ett nätverk och få det att fungera för data utanför sin exempelsamling använder man en del av data för själva träningen och en annan del för att utvärdera resultatet av träningen. Det är viktigt att en separat mängd används för utvärderingen. Om man tränar upp modellen på samma mängd som man mäter resultatet med, så kommer man få en modell som är väldigt bra på exakt det data som den har sett, men å andra sidan vara väldigt dålig på nytt okänt data. Detta kallas överträning eller ’overfitting’.

En annan svårighet kan vara att data inte representerar verkligheten tillräckligt bra och således drar felaktiga slutsatser. Forskning har visat att det ibland leder till att fördomar till och med förstärks i modellerna.

Ett experiment

Det finns många verktyg på marknaden för maskinlärning, för olika plattformar och språk. Denna gång tänkte jag titta närmare på Tensorflow från Google.

Mitt experiment går ut på att skapa en modell som föreslår nästa ord givet ett antal ord. En form av ’auto suggest’ som man till exempel kan hitta i tangentbordet i mobilen. Tensorflow har både låg- och högnivå API:er och finns i språken Python, C++ och Java. Här har jag valt att köra det i Python. Som datakälla har jag valt boken Nils Holgerssons resa som kan laddas ner från http://runeberg.org/nilsholg/. Nu vet jag att denna datamängd inte räcker för att representera det svenska språket på ett tillräckligt bra sätt, men det får duga för ett experiment. Texten består av ca 232 000 ord.

Min idé är att låta varje ord vara ett värde; exempelvis en mening som ”Det var en gång” och ordlistan ”Det” = 43, ”var” = 652, ”en” = 12 och ”gång” = 1002 skulle ge sekvensen 43, 652, 12, 1002 som data. Utdata blir en sannolikhet för varje ord i vokabulären som nästa ord. För att ge ett förslag på nästa ord väljer jag att ta det mest sannolika ordet varje gång. Det går här att ge topp 5-orden om man vill på ett enkelt sätt. Mitt nätverk kommer bestå av några lager med LSTM-nät och för att transformera de diskreta talen till vektorer av reella tal kommer jag använda något som kallas Embeddings. Detta gör att jag lätt kan välja dimension på nätverket för att anpassa inlärningen.

Varning! Nedanför kommer kod och tekniskt mumbo-jumbo.

Man kan scrolla ner till slutet och se resultatet om det är intressant…

Tensorflow

Tensorflow är baserat på att man bygger upp en graf för hur exekveringen ska utföras. I denna graf definierar man variabler, operationer samt behållare för riktiga värden. När grafen är byggd så kan denna köras i en session där de riktiga beräkningarna kommer att ske. Tensorflow är byggt för att köras distribuerat och på GPU för att accelerera körningar. Man måste inte ha en grafikprocessor, men det är en klar fördel när det är många beräkningar som behöver ske. Att gå från att köra beräkningar över natten till under en timme gör det till ett krav för att arbeta med.

Bygga upp nätverket

Min input kommer vara en tvådimensionell matris, eller ”tensor”, med dimensionerna [batch-storlek, sekvenslängd] där batch-storlek är antalet exempel som körs samtidigt och sekvenslängden är antalet ord i exemplet.

inputs = tf.reshape(inputs, [-1, config.num_steps])
embedding = tf.get_variable(


"embedding", [vocab_size, size], dtype=tf.float32)

inputs = tf.nn.embedding_lookup(embedding, inputs)

Embedding är här en variabel som definieras med dimensionerna alla möjliga ord i modellen samt storleken på LSTM-lager. Sedan transformeras indatat från heltal till vektorer med rätt antal element.

Definitionen av nätverket görs sedan genom att skapa en BasicLSTMCell för varje lager och slå i upp dessa till en enhet m.h.a MultiRNNCell

cell = tf.contrib.rnn.MultiRNNCell(

[tf.contrib.rnn.BasicLSTMCell(size) for _ in range(config.num_layers)])

För att mata in vår input i cellen så behöver det först formateras korrekt. Funktionen static_rnn vill ha en lista med tensorer av dimensionerna [batch-storlek, input-storlek], där varje tensor är ett steg i sekvensen. Funktionen unstack hjälper till att dela upp datat till listan.

inputs = tf.unstack(inputs, num=config.num_steps, axis=1)

outputs, next_state =

tf.nn.static_rnn(cell, inputs, self.state, dtype = tf.float32)

Outputs är nu en lista med resultat från varje steg. Detta kommer under träningen att användas till optimeringsmetoden för att anpassa vikterna i systemet.

Bygga upp träning

För att beräkna felet och hålla för att inte göra det allt för svårt så använder jag en metod som givet output och målvärden räknar ut korsentropin i sekvenser. Detta är väldigt matematiskt och går att läsa mer om, men jag väljer att ta den snabba vägen här och använda en färdig metod.

loss = tf.contrib.seq2seq.sequence_loss(

self.rnn.logits,
targets,
tf.ones([config.batch_size, config.num_steps],


dtype=tf.float32))

För att nu minimera denna “förlust” använder jag summan av hela batchens förluster och använder ”Gradient descent” för att förändra variabler. Ni som är bekanta med matte och algoritmer för att hitta minimum och maximum i ekvationer känner nog igen metoden där man steg för steg går ner för en lutning med kortare och kortare steg. Denna finns såklart inbyggd i Tensorflow. Jag har lagt in ett steg för att klippa gradienterna som sägs vara det korrekta sättet, enligt Tensorflow. Detta gör man för att undvika problem med gradienter som växer obehindrat eller försvinner.

cost = tf.reduce_sum(loss)
optimizer = tf.train.GradientDescentOptimizer(learning_rate)
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars),


config.max_grad_norm)

training = optimizer.apply_gradients(zip(grads, tvars))

För att sedan köra igenom träningen så måste en session sättas upp och här finns det stöd för att automatiskt spara tillståndet under körning och läsa in vid uppstart.

with tf.Graph().as_default():

init = tf.global_variables_initializer()

# Bygg upp grafen med träning och LSTM
trainer = Trainer(train_data, config)

sv = tf.train.Supervisor(logdir=FLAGS.save_path)

with sv.managed_session() as session:


session.run(init)
feed_dict = {}
for epoch in range(config.max_max_epoch):
for i in range(trainer.epoch_size):
_, the_cost, current_state =

session.run([trainer.training,


trainer.cost,
trainer.rnn.next_state],
feed_dict = feed_dict)


feed_dict[trainer.rnn.state[0]] = current_state[0]
feed_dict[trainer.rnn.state[1]] = current_state[1]

Efter varje batch skickar vi tillbaka cellernas tillstånd i feed_dict som håller värden som ska användas i körningen. Metoden run tar en lista över de operationer som ska utföras och ge värden ifrån. Som nyckel i feed_dict används den tensor eller operation som ska ta emot värden så jag pekar här ut ”state” som ligger i ”rnn” i min ”trainer”. Statet för en LSTM är som standard en tuple med två värden som här måste pekas ut var för sig.

Den fullständiga koden för mitt experiment finns att hitta på här: https://github.com/tobhult/tf-lstm-experiment

Det finns gott om förbättringspunkter i experimentet. Bland annat saknas en utvärdering av förlusten med hjälp av testdata. Just nu körs bara träningen ett förbestämt antal omgångar vilket kan ge en övertränad modell. En annan förbättring skulle kunna vara att läsa in fler böcker samtidigt och därmed utöka mängden data.

Slutsatser

Som nybörjare med Tensorflow kan man lätt missförstå hur det fungerar. Det är lätt att tro att koden man skriver exekverar beräkningar när man egentligen bara bygger upp en graf för hur det ska utföras. Det gäller att för varje steg hålla reda på dimensioner i tensorer som bollas runt, ibland behöver man forma om dem för att passa nästa beräkning men man får tydliga fel som beskriver felet.

Efter att ha tränat med 2 lager med 400 noder i varje och kört igenom hela texten 30 gånger i träning under ca 5 timmar utan GPU får jag följande, där fetstilt är det jag skickat in.

(OBS. Jag har även separerat in punkter, komman, frågetecken, utropstecken, citationstecken och de html-taggar som finns i datat som egna ”ord”)
Jag vill ha en av dem den där tiden, som jag hade fått fråga var det med dem.”  <p> Karr sträckte mot örnen
Stockholm borde nog kanske gå något, som är så vis, ”sade hon.” Men jag tror inte, att jag kan glömma
Han visade sig vara en lång stund. Det var, som om han hade haft lust att göra, men han blev på en lång
Det var dags att se. Det var, som om den ena djuret hade blivit sämre än den där hade givit sig ut över
Nu ska jag ha drömt för, om det bara en gång har varit ett stycke deg. <p> Det var märkvärdigt med detta

Som vi kan se så har det blivit lite osammanhängande delar av meningar. Den försöker återskapa stycken från boken kan man se men lyckas inte helt. För att göra en bättre modell kan det krävas mer data, fler lager eller större lager. En sak som är säker är att man behöver mycket tid och dyr hårdvara.

An introduction to Reactive Programming with RxJava – Part #3: Convert a traditional web application to a reactive

In my last two blog entries, I’ve given an introduction to reactive programming and RxJava. In this third and final part I will show how you can convert a traditional web application to a reactive one.

All the code will be available at https://gitlab.com/perlilja/rxAirlineDemo, there will also be the instructions of how to run the application. To get a full insight, I suggest you read the code. The final version is merged to the master branch, and the original version is found on before_rxjava branch.

The application architecture

The application consists of three parts; the third-party API, the backend and the client. The third-party API’s will stay the same, and represent an external API that we don’t have control over. The backend and the client is where we will make the changes to convert a traditional server/client application to a responsive web application. But first, let me explain the traditional web application.

The legacy application architecture

The architecture and the flow of the application is explained in the image below.

It works like this; the client calls the backend, which then makes two calls to each third part API. One call for fetching all possible destinations for an airline for the given source, and thereafter it fetches all flights for each destination. All is done synchronously, which means it will first fetch the data from the EasyJetAPI, and not until it has fetched all the data for that API it will continue to the next one. When fetched all the data from the three different APIs, it will return all the flights in one big JSON response that will be processed and rendered by the client.

Converting to a reactive architecture

To change the web application to a reactive application, we first need to convert the response from the API to an Observable instead. This is easily done by creating an Observable from the response we got from the API, like this:

Observable result = Observable.fromArray(restTemplate.getForObject(encodeURI("http://localhost:10002/easyjet/api/destinations/{from}", from),DestinationDTO[].class));

The next step is to use the new Observable when fetching the data, for example before we did the following:

List possibleEasyJetDestinations = easyJetService.getDestinations(from);

for (DestinationDTO dest : possibleEasyJetDestinations) {
List tmpFlights = easyJetService.getFlights(from, dest.getTo());
tmpFlights.stream().forEach(f -> f.setAirline("EasyJet"));
allFlights.addAll(tmpFlights);
}

Now we can use the power of Observables and first fetch the destinations and then use the flatMap operator to fetch the flights. The subscibeOn method tells the Observable that we want to run this operation in another thread than the main thread. The advantage of doing this, is that each of these services will run in parallel (asynchronously), instead of after each other (synchronously).

easyJetService.getDestinations(from)
.subscribeOn(Schedulers.io())
.flatMap(dest -> easyJetService.getFlights(from, dest.getTo()))
.map(f -> new FlightDTO(f.getFrom(), f.getDestination(), f.getDeparture(), f.getArrival(), f.getPrice(), "EasyJet"))

And now that each service is returning an Observable, we can use merge to join the three Observables that we got from the three different services (one for each external API).

As a last step, we change the FlightsController from returning the response as one big JSON, to instead take the advantage of Server-sent Events (SSE). SSE is a HTML5 standard, where updates or small chunks of data is push to the client. In our case we are sending each FlightDTO as an update to the client. This means that the client doesn’t need to wait for the whole response before it can start rendering the data. Instead it can start render as soon as it receives the first FlightDTO object. The support for SSE is built in Spring Boot, and is supported by most web browsers.

SseEmitter sseEmitter = new SseEmitter();
airlineService.getPossibleDestinations(from).subscribe(a -> {
sseEmitter.send(a);
},sseEmitter::completeWithError,sseEmitter::complete);

return sseEmitter;

I will not explain the client part, but do take a look at the code at Gitlab. The client application is based on Angular 4 and uses RxJS.

Conclusion

So, what are the advantages of using RxJava? The big advantage is that we will get a more reactive application, where the data is displayed to the user in a much faster way. We were also able to divide the execution of the code into different threads, and in that way, make the code less synchronously (and almost three times faster). Of course, we could also have done this with the legacy application, but that wouldn’t be as easy.

And furthermore – even though it’s my very personal opinion – the code becomes much more readable.

Follow up; från produktbolag till konsultbolag – hur gick det?

För nästan ett år sedan tog jag ett stort och svårt beslut. Att efter 14 år på ett och samma företag byta arbetsgivare, och att dessutom gå från produktbolag till konsultbolag, var absolut inget lätt beslut.

Så; hur gick det då?

Sommaren är förhoppningsvis en tid för vila och reflektion för oss alla och för mig var det naturligt att i år reflektera över mina första 6 månader som konsult. Det som jag hela tiden återkommer till när jag ser tillbaka är människor. Det är människorna som gör skillnaden. Jag kom rakt in i ett helt fantastiskt gäng som stöttar och utmanar mig och som jag också har så oerhört kul med. För mig är det ett kvitto på att det som fick mig att välja One, det vill säga värderingarna, inte bara är tryckta på väggen utan i högsta grad efterlevs. Dessutom, och precis lika viktigt, så matchar de mina egna värderingar. Jag har inte bara fått nya kollegor, jag har också fått nya vänner.

En annan sak som lockade med att byta från produktbolag till konsultbolag var möjligheten att få komma ut och hjälpa en mängd olika företag; att hela tiden få chans att utvecklas och lära sig nya saker. Jag är fortfarande ute på mitt första uppdrag så där har jag lite svårt att uttala mig om det lever upp till mina förväntningar, men jag är rätt säker på att jag inte kommer bli besviken. Förhopningen att få komma ut och lära sig nya saker som man inte trodde på förhand kunde inte blir mer rätt. Jag är ute hos en kund som jag aldrig hört talas om innan, i en bransch som jag knappt visste existerade och jag har lärt mig otroligt mycket.

Och de där sakerna som jag oroade mig för, hur är det med dom?

Om vi börjar med att titta på oron över att få ett uppdrag långt bort som gör livspusslet svårare att få ihop så är det klart att den oron kommer när mitt nuvarande uppdrag närmar sig slutet. Skånetrafikens punktlighet de senaste månaderna gör ju inte saken bättre, men precis som min uppfattning var innan så är jag övertygad att vi kan lösa det på bästa sätt för alla inblandade.

Oron över att få ihop en bra teamkänsla när man inte ses varje dag på jobbet är absolut utraderad. Med alla härliga människor, tydliga värderingar och tydlig kommunikation om vad som är viktigt från One Agency’s sida är det absolut inget problem. Förutom att jag gärna hade jobbat ännu tightare med mina fantastiska One-kollegor.

En sak som jag innan inte alls hade reflekterat över innan var hur det här med debitering skulle påverka mig. Det är det enda som jag ibland kan tycka är lite påfrestande – har jag debiterat för många timmar? Har jag debiterat för få timmar? Når jag upp till målet? Jag trodde inte det skulle påverka mig så pass mycket som det faktiskt gör. Här vill jag vara väldigt tydlig med att säga att det inte är någon annan än jag själv som sätter den pressen på mig, och när jag pratar med min chef om det så får jag ett fantastiskt stöd.

Så, om jag skulle fatta beslutet igen att byta från min arbetsgivare till One, skulle jag göra samma val? Absolut!

Courage To Change – and what about the ”magkänsla”?

Vi har alla stått inför val här i livet. Vissa lätta – skinka eller ost på frukostmackan – andra lite svårare – byta jobb, relationer. Vi tar dessa beslut på olika sätt; vi kan basera våra beslut enbart på fakta, göra en lista med för- och nackdelar, be om råd från personer vi litar på eller helt enkelt bara wing it. Och grunden till det sistnämnda är nämligen den berömda magkänslan. Eller möjligtvis den där rösten längst bak i huvudet som många kallar samvete. Den där rösten som rätt snabbt klargör om du är på väg att göra något galet eller om den likt en hejaklacksledare manar dig framåt.

Men kan vi träna upp vår magkänsla? Och isåfall hur? Hur ska vi få den där rösten att guida dig rätt i de beslut som den väljer att göra instick i? Och är det rätt att ta sina beslut helt baserat på just denna? Let’s find out!

Magkänslan är egentligen en blandning av tidigare erfarenheter. Helt omedvetet utvärderar du risk respektive utdelning. Negativa upplevelser, såsom att kastas av en häst, gör att du direkt och omedvetet associerar ridning med hög risk och låg utdelning. Positiva upplevelser, såsom ett lyckat köp av lägenhet, gör att du ser på framtida byten av boende som något med låg risk med hög utdelning. Det är faktiskt så enkelt. Är du glad kommer du att vara mer riskbenägen, medan du i ett ledset eller upprört mode kommer att värdera riskerna högre.

Men det är här det fina kommer in. Debriefing; att utvärdera situationer efter de hänt för att på bästa sätt kunna värdera det som sedan lagras i vår minnesbank. Om vi här kan prata med oss själva kring den där hästen som valde att kasta av oss – varför hände det? Var det något jag gjorde fel eller hade jag bara oturen att välja en bångstyrig ponny? Och glöm för allt i världen inte bort att utvärdera dina positiva upplevelser. Vad gjorde jag som var bra i denna situation och hur kan jag bibehålla denna känsla så länge som möjligt? Således, att faktiskt aktivitet ta beslutet att kunna kontrollera en situation som jag antingen misslyckades i (och lärde mig något av) eller helt enkelt hur jag egentligen lyckades med en uppgift (för att kunna lyckas med den igen eller varför inte göra den ännu bättre).

Så, om vi nu ponerar att vi ska hoppa upp på hästen igen och faktiskt blotta oss för ett nytt eventuellt misslyckande så är det viktigt att man med öppet sinne tagit in information kring sitt misslyckande. Både från sin egna debriefing, men också från omgivningen. Och nu kommer vi till feedback. För vi vet ju alla att feedback är en gåva, eller hur? Den som tar emot den väl kommer att motta den om och om igen. För om jag här i mitt misslyckande ändå har handlingskraften och viljan att vända det hela så behöver jag ju veta hur jag kan göra något bättre. Kan jag göra det bättre? Har jag förutsättningarna för det? Kan jag bli riktigt bra på något?

Vi pratar ofta om handlingskraft och förändringsbenägenhet på One Agency. Mitt egna höstlöfte kommer vara att ta tag i ett 15 år gammalt misslyckande i form av ett uteblivet körkort. Risken är hög och utdelningen känns just nu väldigt låg. Jag står typ längst ner på feedbacktrappan (”det går inte!”) med minnen från en landsvägskörning inkluderande multipla motorstopp påträngande nära. Men, genom att övervinna ovan tankevurpor så tänker jag faktiskt klara detta. Det kommer nog krävas rätt mycket mental träning och därmed känns semestern som en bra start.

Glad, föränderlig och actionfylld sommar!
#CourageToChange #TakeMassiveAction