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

63,5% (127/200) om dolda testfall

En enkel heuristik baserad på titelns längd, antal mellanslag och användning av -ly suffix.

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

Prova online!

Kommentarer

• Detta är absurt effektivt för hur enkelt det är.
• Denna lösning fick 63,5% på de dolda testfallet, så det är giltigt.
• Inte så enkelt som det var möjligt i början av sandlådan (100%, med kapitaliseringsskillnader innan den standardiserades) men det här är verkligen enkelt.
• @Mego Bara av nyfikenhet förbättrar den här NSFW-versionen poängen på de dolda testfallet? 🙂
• @Arnauld 66% med den versionen

Python 3, 84%

Otestad på dolda testfall.

Detta använder Keras LSTM RNN utbildad i olika rubriker. För att köra det behöver du Keras följande och modellen som jag har gjort tillgänglig på GitHub: repolänk . Du behöver modellen .h5 och ord- / vektormappningarna finns i .pkl. De senaste

Beroenden är:

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 

Inställningarna är:

max_headline_length = 70 word_count = 20740 

Modellen är:

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")) 

Nu för att ladda modellen och ordet inbäddningar:

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

Och koden för att testa om en sträng är från ”NotTheOnion” eller ”TheOnion ”Jag har skrivit en snabb hjälpfunktion som omvandlar strängen till respektive ordinbäddning:

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 

Förklaring

Den här koden kör en modell som analyserar förhållandet mellan ord genom att representera orden som en ”vektor”. Du kan läsa mer om inbäddning av ord här .

Detta utbildas i rubriker men testfallet är uteslutet .

Dessa processer automatiseras efter en hel del bearbetning. Jag har distribuerat den slutliga bearbetade ordlistan som en .pkl men vad som händer i ordinbäddning är att vi först analyserar meningen och isolerar orden.

Efter att vi nu har orden nästa steg är att kunna förstå skillnaderna och likheterna mellan vissa ord t.ex. king och queen kontra duke och duchess. Dessa inbäddningar sker inte mellan de faktiska orden men mellan siffrorna som representerar orden, vilket är det som är lagrat i .pkl -fil. Ord som maskinen inte förstår mappas till ett speciellt ord <UNK> vilket gör att vi kan förstå att det finns ett ord där men att det inte är exakt känt vad meningen är.

Nu när orden kan förstås måste ordsekvensen (rubrik) kunna analyseras. Detta är vad ”LSTM” gör, en LTSM är en typ av ”RNN” -cell som undviker den försvinnande gradienteffekten. Mer enkelt tar det i en ordsekvens och det gör att vi kan hitta relationer mellan dem.

Nu är det sista lagret Dense vilket i grund och botten betyder att det är som en matris som betyder att utdata är som: [probability_is_not_onion, probability_is_onion]. Genom att hitta vilken som är större kan vi välja vilken som är det mest säkra resultatet för den angivna rubriken.

Python 3 + Keras, 41/50 = 82%

83% (166/200) på dolda testfall

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 och vocabulary.json kan hämtas från här (mycket stort) och här .

Fullt ansluten klassificerare ansluten till en förutbildad sentimentanalysmodell DeepMoji, som består av staplade dubbelriktade LSTM och en uppmärksam mekanism. Jag frös DeepMoji-lagren och tog ut det sista softmax-lagret, tränade bara de helt anslutna lagren och frystade sedan DeepMoji-lagren och tränade dem tillsammans för finjustering. Uppmärksamhetsmekanismen är hämtad från https://github.com/bfelbo/DeepMoji/blob/master/deepmoji/attlayer.py (jag ville inte behöva använda all sin kod som ett beroende för en klass, speciellt eftersom det är Python 2 och ganska svårt att använda som en modul …)

Detta fungerar förvånansvärt dåligt på Megos testuppsättning, med tanke på att det på min egen större validering ställde det blir> 90%. Så jag är inte klar med det här ännu.

Kommentarer

• 83% på dolda testfall, förutsatt att jag körde det korrekt

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

96% (192/200) på dolda testfall

 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)); };  

Detta kräver två stora JSON-filer som jag inte kan lägga dem här eller på ” TiO ”. Ladda ned dem från följande länkar och spara dem med words.json och namn, i samma mapp som JS-fil. Det finns också en länk för en JS-fil med testfall och resultat / procentutskrift.Du kan placera dina dolda testfall i onions och nonOnions variabler.

• words.json
• bags.json
• onion.js (detta inkluderar standardtestfall)

När du har sparat alla 3 filerna i samma katalog kör du node onion.js.

O -funktionen returnerar true om det är lök och false om det inte är det. Använder en stor lista med ordpåsar (utan ordning) för att upptäcka om inmatningssträngen är lök. Typ av hårdkodad men fungerar mycket bra på en mängd slumpmässiga test fall.

Kommentarer

• Denna lösning får 96% på de dolda testfall

Arbetar av Arnaulds lösning

JavaScript (ES6), 41/50

64% (128/200) på dold testfall

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å dolda testfall (ogiltiga)

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 

Längd + ordantal + ”ly ”konceptet fungerar ganska bra, jag kunde pressa ut några fler punkter genom att söka efter ordet” pappa ”(när talar riktiga artiklar om människors pappor i tredje person i titeln?) och en ytterligare punkt genom att ändra ”ly” -sökande heuristik och kontrollera om det finns nummer i titeln (vilket i allmänhet kan vara mindre giltigt utanför testet, så jag lämnade båda lösningarna)

Kommentarer

• Jag vet inte ’ vet inte om pappadelen … verkar lite som att optimera testfallet för mig …
• Och ja, jag kan hitta massor av Not Onion-artiklarna som nämner pappor
• Det ’ är förmodligen ett bättre sätt att göra det som en del av heuristiken och inte bara en hård ” vinner ” om det innehåller pappa, men jag föreställer mig att även utanför testdatabasen abstrakt talar om en specifik ” Pappa ” är vanligare på The Onion
• Din första lösning fick 64% på dolda testfall, så den är giltig. Din andra lösning fick 62,5% på dolda testfall, så den är inte giltig.
• @Mego Vilken nära marginal …