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

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

En simpel heuristisk baseret på længden af titlen, antallet af mellemrum og brug af -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øsning scorede 63,5% på de skjulte testtilfælde, så det er gyldigt.
• Ikke så simpelt som det var muligt i begyndelsen af sandkassen (100%, ved at bruge forskelle i store bogstaver, før den blev standardiseret), men dette er virkelig simpelt. >
• @Mego Forbedrer denne NSFW version bare af nysgerrighed scoren på de skjulte testsager? 🙂
• @Arnauld 66% med den version

Python 3, 84%

Utestet på skjulte testsager.

Dette bruger Keras LSTM RNN, der er trænet i forskellige overskrifter. For at køre det har du brug for Keras følgende og den model, som jeg har gjort tilgængelig på GitHub: repo link . Du skal bruge modellen .h5 og ord- / vektortilknytningerne er i .pkl. Den seneste

Afhængigheden 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 

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

Nu for at indlæse modellen og ordet embeddings:

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

Og koden for at teste, om en streng er fra “NotTheOnion” eller “TheOnion “Jeg har skrevet en hurtig hjælperfunktion, der konverterer strengen til de respektive ordindlejringer:

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 kode kører en model, der analyserer forholdet mellem ord ved at repræsentere ordene som en “vektor”. Du kan lære mere om ordindlejring her .

Dette trænes i overskrifter, men testsagerne er udelukket .

Disse processer automatiseres efter en hel del behandling. Jeg har distribueret den endelige behandlede ordliste som en .pkl men hvad der sker i ordindlejring er først at vi analyserer sætningen og isolerer ordene.

Efter vi nu har ordene det næste trin er at være i stand til at forstå forskellene og lighederne mellem bestemte ord f.eks. king og queen versus duke og duchess. Disse indlejringer sker ikke mellem de faktiske ord, men mellem tal, der repræsenterer ordene, hvilket er det, der er gemt i .pkl fil. Ord, som maskinen ikke forstår, kortlægges til et specielt ord <UNK>, som giver os mulighed for at forstå, at der er et ord der, men at det ikke vides nøjagtigt, hvad meningen er.

Nu hvor ordene kan forstås, skal ordsekvensen (overskrift) kunne analyseres. Dette er hvad “LSTM” gør, en LTSM er en type “RNN” -celle, som undgår den forsvindende gradienteffekt. Mere simpelt tager det en ordsekvens, og det giver os mulighed for at finde relationer mellem dem.

Nu er det sidste lag Dense hvilket grundlæggende betyder, at det er som en matrix, hvilket betyder, at output er som: [probability_is_not_onion, probability_is_onion]. Ved at finde ud af, hvilken der er større, kan vi vælge, hvilken der er det mest sikre resultat for den givne overskrift.

Python 3 + Keras, 41/50 = 82%

83% (166/200) på skjulte testsager

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 (meget stor) og her .

Fuldt tilsluttet klassifikator tilsluttet en foruddannet sentimentanalysemodel DeepMoji, som består af stablede tovejs LSTMer og en opmærksom mekanisme. Jeg frøs DeepMoji-lagene og tog det sidste softmax-lag ud, trænede kun de fuldt forbundne lag og frøs så DeepMoji-lagene ud og trænede dem sammen til finjustering. Opmærksomhedsmekanismen er taget fra https://github.com/bfelbo/DeepMoji/blob/master/deepmoji/attlayer.py (jeg ville ikke have brug for al deres kode som en afhængighed for en klasse, især da det er Python 2 og ret uhåndterligt at bruge som et modul …)

Dette fungerer overraskende dårligt på Megos testsæt, i betragtning af at det på min egen større validering er indstillet får> 90%. Så jeg er ikke færdig med dette endnu.

Kommentarer

• 83% på skjulte testsager, forudsat at jeg kørte det korrekt

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

96% (192/200) på skjulte testsager

 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 kræver to store JSON-filer, som jeg ikke kan placere dem her eller på ” TiO “. Download dem fra følgende links, og gem dem med words.json og navne, i samme mappe som JS-fil. Der er også et link til en JS-fil med testcases og resultat / procentudskrivning.Du kan placere dine skjulte testtilfælde i onions og nonOnions variabler.

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

Efter at have gemt alle 3 filer i samme bibliotek, skal du køre node onion.js.

O -funktionen returnerer true hvis det er løg og false hvis det ikke er “t. Bruger en stor liste med ordposer (uden ordre) til at opdage, om inputstrengen er løg. Slags hårdkodet, men fungerer meget godt på en række tilfældige test sager.

Kommentarer

• Denne løsning får 96% på de skjulte testsager

Arbejder ud af Arnaulds løsning

JavaScript (ES6), 41/50

64% (128/200) på skjult test tilfælde

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 testsager (ugyldige)

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ængde + antal ord + “ly “koncept fungerer ret godt, jeg var i stand til at presse et par flere punkter ud ved at tjekke for ordet” far “(hvornår taler rigtige artikler om folks fædre i tredje person i titlen?) og et yderligere punkt ved at ændre “ly” -søgheuristikken og kontrol af tilstedeværelsen af tal i titlen (hvilket måske er mindre gyldigt i det generelle tilfælde uden for testen, så jeg efterlod begge løsninger)

Kommentarer

• Jeg kender ikke ‘ ikke kender farens del … virker lidt ligesom at optimere testsagen for mig …
• Og ja, jeg kan finde masser af Not the Onion-artikler, der nævner dads
• Der ‘ er sandsynligvis en bedre måde at gøre det som en del af heuristikken og ikke bare en hård ” vinde ” hvis den indeholder far, men jeg forestiller mig, at selv uden for testdatabasen abstrakt taler om en bestemt ” Far ” er mere almindelig på The Onion
• Din første løsning fik 64% på de skjulte testsager, så den er gyldig. Din anden løsning scorede 62,5% på de skjulte testsager, så den er ikke gyldig.
• @Mego Hvilken tæt margen …