JavaScript ( ES7), 39/50 (78%)

63,5% (127/200) om skjulte testtilfeller

En enkel heuristikk basert på tittelens lengde, antall mellomrom og bruk av -ly suffikset.

 isOnion = str => str.length ** 0.25 + str.split(" ").length ** 1.25 * 2 + str.split(/ly\b/).length ** 1.75 * 7 > 76  

Prøv det online!

Kommentarer

• Dette er absurd effektivt for hvor enkelt det er.
• Denne løsningen fikk 63,5% på de skjulte testtilfellene, så det er gyldig.
• Ikke så enkelt som det var mulig i begynnelsen av sandkassen (100%, ved å bruke store bokstaver før den ble standardisert), men dette er veldig enkelt.
• @ Mego Bare av nysgjerrighet, forbedrer denne NSFW-versjonen poengsummen på de skjulte testsakene? 🙂
• @Arnauld 66% med den versjonen

Python 3, 84%

Utestet på skjulte testtilfeller.

Dette bruker Keras LSTM RNN trent på forskjellige overskrifter. For å kjøre det trenger du Keras følgende og modellen som jeg har gjort tilgjengelig på GitHub: repo link . Du trenger modellen .h5 og ord- / vektorkartleggingen er i .pkl. De siste

Avhengighetene er:

import numpy as np from pickle import load from keras.preprocessing import sequence, text from keras.models import Sequential from keras.layers import Dense, Embedding, SpatialDropout1D, LSTM, Dropout from keras.regularizers import l2 import re 

Innstillingene er:

max_headline_length = 70 word_count = 20740 

Modellen er:

model = Sequential() model.add(Embedding(word_count, 32, input_length=max_headline_length)) model.add(SpatialDropout1D(0.4)) model.add(LSTM(64, kernel_regularizer=l2(0.005), dropout=0.3, recurrent_dropout=0.3)) model.add(Dropout(0.5)) model.add(Dense(32, kernel_regularizer=l2(0.005))) model.add(Dropout(0.5)) model.add(Dense(2, kernel_regularizer=l2(0.001), activation="softmax")) 

Nå for å laste inn modellen og ordet embeddings:

model.load_weights("model.h5") word_to_index = load(open("words.pkl", "rb")) 

Og koden for å teste om en streng er fra «NotTheOnion» eller «TheOnion «Jeg har skrevet en rask hjelperfunksjon som konverterer strengen til de respektive ordinnblandingene:

def get_words(string): words = [] for word in re.finditer("[a-z]+|[\"".;/!?]", string.lower()): words.append(word.group(0)) return words def words_to_indexes(words): return [word_to_index.get(word, 0) for word in words] def format_input(word_indexes): return sequence.pad_sequences([word_indexes], maxlen=max_headline_length)[0] def get_type(string): words = words_to_indexes(get_words(string)) result = model.predict(np.array([format_input(words)]))[0] if result[0] > result[1]: site = "NotTheOnion" else: site = "TheOnion" return site 

Forklaring

Denne koden kjører en modell som analyserer forholdet mellom ord ved å representere ordene som en «vektor». Du kan lære mer om innebygging av ord her .

Dette blir trent på overskrifter, men testtilfellene er ekskludert .

Disse prosessene blir automatisert etter ganske mye behandling. Jeg har distribuert den endelige behandlede ordlisten som en .pkl men det som skjer i ordinnbetting er først vi analyserer setningen og isolerer ordene.

Etter at vi nå har ordene neste trinn er å kunne forstå forskjellene og likhetene mellom bestemte ord f.eks. king og queen versus duke og duchess. Disse embeddingene skjer ikke mellom ordene, men mellom tall som representerer ordene, det er det som er lagret i .pkl fil. Ord som maskinen ikke forstår er kartlagt til et spesielt ord <UNK> som lar oss forstå at det er et ord der, men at det ikke er kjent nøyaktig hva meningen er.

Nå som ordene kan forstås, må ordrekkefølgen (overskrift) kunne analyseres. Dette er hva «LSTM» gjør, en LTSM er en type «RNN» -celle som unngår den forsvinnende gradienteffekten. Enklere tar det i en ordsekvens, og det lar oss finne forhold mellom dem.

Nå er det siste laget Dense som i utgangspunktet betyr at den er som en matrise som betyr at utgangen er som: [probability_is_not_onion, probability_is_onion]. Ved å finne hvilken som er større kan vi velge hvilken som er det mest sikre resultatet for den gitte overskriften.

Python 3 + Keras, 41/50 = 82%

83% (166/200) på skjulte testsaker

import json import keras import numpy import re from keras import backend as K STRIP_PUNCTUATION = re.compile(r"[^a-z0-9 ]+") class AttentionWeightedAverage(keras.engine.Layer): def __init__(self, return_attention=False, **kwargs): self.init = keras.initializers.get("uniform") self.supports_masking = True self.return_attention = return_attention super(AttentionWeightedAverage, self).__init__(**kwargs) def build(self, input_shape): self.input_spec = [keras.engine.InputSpec(ndim=3)] assert len(input_shape) == 3 self.W = self.add_weight(shape=(input_shape[2], 1), name="{}_W".format(self.name), initializer=self.init) self.trainable_weights = [self.W] super(AttentionWeightedAverage, self).build(input_shape) def call(self, x, mask=None): logits = K.dot(x, self.W) x_shape = K.shape(x) logits = K.reshape(logits, (x_shape[0], x_shape[1])) ai = K.exp(logits - K.max(logits, axis=-1, keepdims=True)) if mask is not None: mask = K.cast(mask, K.floatx()) ai = ai * mask att_weights = ai / (K.sum(ai, axis=1, keepdims=True) + K.epsilon()) weighted_input = x * K.expand_dims(att_weights) result = K.sum(weighted_input, axis=1) if self.return_attention: return [result, att_weights] return result def get_output_shape_for(self, input_shape): return self.compute_output_shape(input_shape) def compute_output_shape(self, input_shape): output_len = input_shape[2] if self.return_attention: return [(input_shape[0], output_len), (input_shape[0], input_shape[1])] return (input_shape[0], output_len) def compute_mask(self, input, input_mask=None): if isinstance(input_mask, list): return [None] * len(input_mask) else: return None if __name__ == "__main__": model = keras.models.load_model("combined.h5", custom_objects={"AttentionWeightedAverage": AttentionWeightedAverage}) with open("vocabulary.json", "r") as fh: vocab = json.load(fh) while True: try: headline = input() except EOFError: break tokens = STRIP_PUNCTUATION.sub("", headline.lower()).split() inp = numpy.zeros((1, 45)) for i, token in enumerate(tokens): try: inp[0,i] = vocab[token] except KeyError: inp[0,i] = 1 print(model.predict(inp)[0][0] > 0.3) 

combined.h5 og vocabulary.json kan hentes fra her (veldig stor) og her .

Fullt tilkoblet klassifikator koblet til en forhåndstrent sentimentanalysemodell DeepMoji, som består av stablede toveis LSTM og en oppmerksomhetsmekanisme. Jeg frøs DeepMoji-lagene og tok ut det endelige softmax-laget, trente bare de fullt sammenkoblede lagene, så løsnet DeepMoji-lagene og trente dem sammen for finjustering. Oppmerksomhetsmekanismen er hentet fra https://github.com/bfelbo/DeepMoji/blob/master/deepmoji/attlayer.py (Jeg ønsket ikke å måtte bruke all koden sin som en avhengighet for en klasse, spesielt siden den er Python 2 og ganske uhåndterlig å bruke som en modul …)

Dette fungerer overraskende dårlig på Megos testsett, med tanke på at det på min egen større validering satt det får> 90%. Så jeg er ikke ferdig med dette ennå.

Kommentarer

• 83% på skjulte testsaker, forutsatt at jeg kjørte det riktig

JavaScript ( Node.js ), 98% (49/50)

96% (192/200) på skjulte testsaker

 const words = require("./words"); const bags = require("./bags"); let W = s => s.replace(/[^A-Za-z0-9 ]/g, "").toLowerCase().split(" ").filter(w => w.length > 3); let M = b => { for (let i = 0; i < bags.length; i++) { let f = true; for (let j = 0; j < bags[i].length; j++) if (!b.includes(bags[i][j])) { f = false; break; } if (f) return true; } return false; }; let O = s => { let b = []; W(s).forEach(w => { let p = words.indexOf(w); if (p >= 0) b.push(p); }); return (b.length > 0 && M(b)); };  

Dette krever to store JSON-filer som jeg ikke kan sette dem her eller på » TiO «. Last ned dem fra følgende lenker og lagre dem med words.json og navn, i samme mappe som JS-fil. Det er også en lenke for en JS-fil med testtilfeller og utskrift / resultat / prosent.Du kan plassere skjulte testtilfeller i onions og nonOnions variabler.

• words.json
• bags.json
• onion.js (dette inkluderer standard testtilfeller)

Etter å ha lagret alle 3 filene i samme katalog, kjør node onion.js.

O -funksjonen returnerer true hvis det er løk og false hvis det ikke er «t. Bruker en stor liste med ordposer (uten ordre) for å oppdage om inngangsstrengen er løk. Litt hardkodet, men fungerer veldig bra på en rekke tilfeldige tester saker.

Kommentarer

• Denne løsningen får 96% på de skjulte testtilfellene

Arbeider av Arnaulds løsning

JavaScript (ES6), 41/50

64% (128/200) på skjult testtilfeller

str.includes("Dad") || str.length ** .25 + str.split(" ").length ** 1.25 * 2 + str.split(/ly\b/).length ** 1.75 * 7 > 76 

JavaScript (ES6), 42/50

62,5% (125/200) på skjulte testtilfeller (ugyldig)

isOnion = str => str.includes("Dad") || str.length ** .25 + str.split(" ").length ** 1.25 * 2 + str.split(" ").filter(w => w.length > 3 && w.split(/ly/).length > 1).length * 23.54 + /\d/.test(str) * 8 > 76 

Lengden + ordtall + «ly «konseptet fungerer ganske bra, jeg klarte å klemme ut noen flere poeng ved å se etter ordet» pappa «(når snakker ekte artikler om folks pappaer i tredje person i tittelen?) og et ekstra poeng ved å endre «ly» -søket heuristisk og sjekk for tilstedeværelsen av tall i tittelen (som kan være mindre gyldig i det generelle tilfellet utenfor testen, så jeg la igjen begge løsningene)

Kommentarer

• Jeg vet ikke ‘ jeg vet ikke om pappadelen … virker litt som å optimalisere testsaken for meg …
• Og ja, jeg finner mange Not The Onion-artikler som nevner pappaer
• Det ‘ er sannsynligvis en bedre måte å gjøre det som en del av heuristikken og ikke bare en hard » vinn » hvis den inneholder pappa, men jeg forestiller meg at jeg selv utenfor testdatabasen abstrakt snakker om en spesifikk » Pappa » er mer vanlig på The Onion
• Din første løsning fikk 64% på skjulte testtilfeller, så den er gyldig. Den andre løsningen din fikk 62,5% på skjulte testtilfeller, så den er ikke gyldig.
• @Mego Hva en nær margin …