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

63,5% (127/200) em casos de teste ocultos

Uma heurística simples baseada no comprimento do título, número de espaços e uso do sufixo -ly.

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

Experimente online!

Comentários

• Isso é absurdamente eficaz por ser simples.
• Essa solução teve pontuação de 63,5% em os casos de teste ocultos, por isso é válido.
• Não tão simples quanto era possível no início do sandbox (100%, utilizando diferenças de capitalização antes de ser padronizado), mas isso é realmente simples.
• @Mego Só por curiosidade, esta versão NSFW melhora a pontuação nos casos de teste ocultos? 🙂
• @Arnauld 66% com essa versão

Python 3, 84%

Não testado em casos de teste ocultos.

Isso usa Keras LSTM RNN treinado em várias manchetes. Para executá-lo, você precisa do seguinte Keras e do modelo que disponibilizei no GitHub: link do repo . Você precisará do modelo .h5 e os mapeamentos de palavra / vetor estão em .pkl. Os mais recentes

As dependências são:

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 

As configurações são:

max_headline_length = 70 word_count = 20740 

O modelo é:

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

Agora, para carregar o modelo e a palavra embeddings:

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

E o código para testar se uma string é de “NotTheOnion” ou “TheOnion “Escrevi uma função auxiliar rápida que converte a string para os respectivos embeddings de palavras:

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 

Explicação

Este código executa um modelo que analisa as relações entre palavras, representando as palavras como um “vetor”. Você pode aprender mais sobre incorporação de palavras aqui .

Isso é treinado em títulos, mas os casos de teste são excluídos .

Este processo é automatizado após bastante processamento. Distribuí a lista final de palavras processadas como .pkl, mas o que acontece na incorporação de palavras é primeiro analisarmos a frase e isolarmos as palavras.

Depois de agora ter as palavras, a próxima etapa é ser capaz de entender as diferenças e semelhanças entre certas palavras, por exemplo, king e queen versus duke e duchess. Esses embeddings não acontecem entre as palavras reais, mas entre os números que representam as palavras que são armazenados no .pkl arquivo. Palavras que a máquina não entende são mapeadas para uma palavra especial <UNK> que nos permite entender que existe uma palavra ali, mas que não se sabe exatamente qual é o significado.

Agora que as palavras podem ser compreendidas, a sequência de palavras (título) precisa ser analisada. Isso é o que “LSTM” faz, um LTSM é um tipo de célula “RNN” que evita o efeito de gradiente de desaparecimento. De forma mais simples, leva em uma sequência de palavras e nos permite encontrar relações entre elas.

Agora, a camada final é Dense o que basicamente significa que é uma espécie de array, o que significa que a saída é como: [probability_is_not_onion, probability_is_onion]. Ao descobrir qual é o maior, podemos escolher qual é o resultado mais confiável para o título fornecido.

Python 3 + Keras, 41/50 = 82%

83% (166/200) em casos de teste ocultos

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 podem ser recuperados aqui (muito grande) e aqui .

Classificador totalmente conectado conectado a um modelo de análise de sentimento pré-treinado DeepMoji, que consiste em LSTMs bidirecionais empilhados e um mecanismo de atenção. Eu congelei as camadas DeepMoji e tirei a camada softmax final, treinei apenas as camadas totalmente conectadas, então descongelei as camadas DeepMoji e as treinei juntas para ajuste fino. O mecanismo de atenção é retirado de https://github.com/bfelbo/DeepMoji/blob/master/deepmoji/attlayer.py (eu não queria ter que usar todo o seu código como uma dependência para uma classe, especialmente porque é Python 2 e bastante difícil de usar como um módulo …)

Isso tem um desempenho surpreendentemente ruim no conjunto de teste do Mego, considerando que em meu próprio conjunto de validação maior obtém> 90%. Então, ainda não terminei com isso.

Comentários

• 83% em casos de teste ocultos, presumindo que o executei corretamente

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

96% (192/200) em casos de teste ocultos

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

Isso requer dois grandes arquivos JSON, que não posso “colocá-los aqui ou no ” TiO “. Faça download deles nos links a seguir e salve-os com words.json e nomes, na mesma pasta do arquivo JS. Há também um link para um arquivo JS com casos de teste e resultado / impressão percentual.Você pode colocar seus casos de teste ocultos em variáveis onions e nonOnions.

• words.json
• bags.json
• onion.js (inclui casos de teste padrão)

Depois de salvar todos os 3 arquivos no mesmo diretório, execute node onion.js.

A função O retornará true se for cebola e false se não for. Usa uma grande lista de pacotes de palavras (sem ordem) para detectar se a string de entrada é cebola. Tipo de código rígido, mas funciona muito bem em uma variedade de testes aleatórios casos.

Comentários

• Esta solução obtém 96% nos casos de teste ocultos

Trabalhando na solução de Arnauld “

JavaScript (ES6), 41/50

64% (128/200) em oculto casos de teste

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) em casos de teste ocultos (inválido)

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 

O comprimento + contagem de palavras + “ly “o conceito funciona muito bem, consegui extrair mais alguns pontos ao verificar a palavra” pai “(quando os artigos reais falam sobre os pais das pessoas na terceira pessoa do título?) e um ponto adicional ao alterar a heurística de pesquisa “ly” e verificação da presença de números no título (o que pode ser menos válido no caso geral fora do teste, então deixei as duas soluções)

Comentários

• Eu não ‘ não sei sobre a parte do pai … parece um pouco como otimizar o caso de teste para mim …
• E sim, posso encontrar muitos artigos do Not the Onion mencionando pais
• Há ‘ provavelmente uma maneira melhor de fazer isso como parte da heurística e não apenas um difícil ” win ” se contiver pai, mas imagino que até mesmo fora do banco de dados de teste falando abstratamente sobre um ” Dad ” é mais comum no The Onion
• Sua primeira solução marcou 64% nos casos de teste ocultos, por isso é válida. Sua segunda solução obteve 62,5% nos casos de teste ocultos, então não é válida.
• @Mego Que margem próxima …