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

63,5% (127/200) su casi di test nascosti

Una semplice euristica basata sulla lunghezza del titolo, numero di spazi e utilizzo del -ly suffisso.

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

Provalo online!

Commenti

• Questo è assurdamente efficace per quanto sia semplice.
• Questa soluzione ha ottenuto il 63,5% su i casi di test nascosti, quindi è valido.
• Non così semplice come era possibile allinizio del sandbox (100%, utilizzando le differenze di maiuscole prima che fosse standardizzato) ma questo è davvero semplice.
• @Mego Solo per curiosità, questa versione NSFW migliora il punteggio dei casi di test nascosti? 🙂
• @Arnauld 66% con quella versione

Python 3, 84%

Non testato su casi di test nascosti.

Utilizza Keras LSTM RNN addestrato su vari titoli. Per eseguirlo hai bisogno di Keras quanto segue e del modello che ho reso disponibile su GitHub: repo link . Avrai bisogno del modello .h5 e le mappature parola / vettore sono in .pkl. Le ultime

Le dipendenze sono:

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 

Le impostazioni sono:

max_headline_length = 70 word_count = 20740 

Il modello è:

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

Ora per caricare il modello e la parola embeddings:

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

E il codice per verificare se una stringa proviene da “NotTheOnion” o “TheOnion “Ho” scritto una rapida funzione di supporto che converte la stringa nelle rispettive parole incorporate:

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 

Spiegazione

Questo codice esegue una modello che analizza le relazioni tra le parole rappresentando le parole come un “vettore”. Puoi trovare ulteriori informazioni sullincorporamento di parole qui .

Questo è addestrato sui titoli ma i casi di test sono esclusi .

Questo processo è automatizzato dopo un po di elaborazione. Ho distribuito lelenco di parole elaborato finale come .pkl ma ciò che accade nellincorporamento di parole è prima di analizzare la frase e isolare le parole.

Dopo ora avere le parole il passaggio successivo è essere in grado di comprendere le differenze e le somiglianze tra determinate parole, ad esempio king e queen rispetto a duke e duchess. Questi incorporamenti non si verificano tra le parole effettive ma tra i numeri che rappresentano le parole che è ciò che è memorizzato nel .pkl file. Le parole che la macchina non “capisce” vengono mappate su una parola speciale <UNK> che ci permette di capire che cè una parola lì ma che non si sa esattamente quale sia il significato.

Ora che le parole possono essere comprese, la sequenza di parole (titolo) deve poter essere analizzata. Questo è ciò che fa “LSTM”, un LTSM è un tipo di cella “RNN” che evita leffetto sfumato di fuga. Più semplicemente, prende una sequenza di parole e ci permette di trovare le relazioni tra loro.

Ora lo strato finale è Dense che in pratica significa che è un po come un array, il che significa che loutput è come: [probability_is_not_onion, probability_is_onion]. Trovando quale è più grande possiamo scegliere quale è il risultato più sicuro per il titolo dato.

Python 3 + Keras, 41/50 = 82%

83% (166/200) su casi di test nascosti

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 e vocabulary.json possono essere recuperati da qui (molto grande) e qui .

Classificatore completamente connesso collegato a un modello di analisi del sentiment pre-addestrato DeepMoji, che consiste di LSTM bidirezionali impilati e un meccanismo di attenzione. Ho congelato gli strati DeepMoji e ho tolto lultimo strato softmax, allenato solo gli strati completamente collegati, quindi ho scongelato gli strati DeepMoji e li ho addestrati insieme per la messa a punto. Il meccanismo dellattenzione è preso da https://github.com/bfelbo/DeepMoji/blob/master/deepmoji/attlayer.py (non volevo “t volere utilizzare tutto il loro codice come dipendenza per una classe, soprattutto perché è Python 2 ed è piuttosto ingombrante da usare come modulo …)

Questo funziona sorprendentemente male sul set di test di Mego, considerando che sul mio set di convalida più grande lo imposta ottiene> 90%. Quindi non ho ancora finito con questo.

Commenti

• 83% su casi di test nascosti, supponendo di averlo eseguito correttamente

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

96% (192/200) su casi di test nascosti

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

Ciò richiede due file JSON di grandi dimensioni che non posso “mettere qui o su ” TiO “. Scaricali dai seguenti link e salvali con words.json e nomi, nella stessa cartella del file JS. Cè anche un collegamento per un file JS con casi di test e stampa dei risultati / percentuale.Puoi inserire i tuoi casi di test nascosti nelle variabili onions e nonOnions.

• words.json
• bags.json
• onion.js (questo include casi di test predefiniti)

Dopo aver salvato tutti e 3 i file nella stessa directory, esegui node onion.js.

La funzione O restituirà true se è onion e false se non è “t. Utilizza un ampio elenco di sacchi di parole (senza ordine) per rilevare se la stringa di input è onion. È un po hardcoded, ma funziona molto bene su una varietà di test casuali casi.

Commenti

• Questa soluzione ottiene il 96% sui casi di test nascosti

Elaborazione della soluzione di Arnauld

JavaScript (ES6), 41/50

64% (128/200) su nascosto casi di test

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) su casi di test nascosti (non validi)

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 

La lunghezza + il conteggio delle parole + “ly “Il concetto funziona abbastanza bene, sono riuscito a spremere qualche altro punto controllando la parola” Papà “(quando i veri articoli parlano dei padri delle persone nella terza persona nel titolo?) e un ulteriore punto modificando la ricerca “ly” euristica e il controllo della presenza di numeri nel titolo (che potrebbe essere meno valido nel caso generale al di fuori del test, quindi ho lasciato entrambe le soluzioni)

Commenti

• Non ‘ non so della parte del papà … mi sembra un po come ottimizzare il test case …
• E sì, posso trovare molti articoli di Not the Onion che menzionano i papà
• Là ‘ è probabilmente un modo migliore per farlo come parte delleuristica e non solo un duro ” win ” se contiene papà, ma immagino che anche al di fuori del database di test si parli astrattamente di uno specifico ” Dad ” è più comune su The Onion
• La tua prima soluzione ha ottenuto il 64% sui casi di test nascosti, quindi è valida. La tua seconda soluzione ha ottenuto il 62,5% sui casi di test nascosti, quindi non è valida.
• @Mego What a close margin …