L'apprendimento automatico può apprendere una funzione come trovare il massimo da un elenco?

Ho un input che è un elenco e l'output è il massimo degli elementi dell'elenco input.

L'apprendimento automatico può apprendere una tale funzione che seleziona sempre il massimo degli elementi di input presenti nell'input?

Questa potrebbe sembrare una domanda piuttosto elementare, ma potrebbe darmi una comprensione di ciò che l'apprendimento automatico può fare in generale. Grazie!

Forse , ma nota che questo è uno di quei casi in cui l'apprendimento automatico non è la risposta . Vi è la tendenza a provare e l'apprendimento automatico di calzascarpe nei casi in cui le soluzioni basate su regole standard di palude sono più veloci, più semplici e generalmente la scelta giusta: P

Solo perché puoi, non significa che dovresti

Modifica : originariamente ho scritto questo come "Sì, ma nota che ..." ma poi ho iniziato a dubitare di me stesso, non avendo mai visto farlo. L'ho provato oggi pomeriggio ed è certamente fattibile:

import numpy as np
from keras.models import Model
from keras.layers import Input, Dense, Dropout
from keras.utils import to_categorical
from sklearn.model_selection import train_test_split
from keras.callbacks import EarlyStopping

# Create an input array of 50,000 samples of 20 random numbers each
x = np.random.randint(0, 100, size=(50000, 20))

# And a one-hot encoded target denoting the index of the maximum of the inputs
y = to_categorical(np.argmax(x, axis=1), num_classes=20)

# Split into training and testing datasets
x_train, x_test, y_train, y_test = train_test_split(x, y)

# Build a network, probaly needlessly complicated since it needs a lot of dropout to
# perform even reasonably well.

i = Input(shape=(20, ))
a = Dense(1024, activation='relu')(i)
b = Dense(512, activation='relu')(a)
ba = Dropout(0.3)(b)
c = Dense(256, activation='relu')(ba)
d = Dense(128, activation='relu')(c)
o = Dense(20, activation='softmax')(d)

model = Model(inputs=i, outputs=o)

es = EarlyStopping(monitor='val_loss', patience=3)

model.compile(optimizer='adam', loss='categorical_crossentropy')

model.fit(x_train, y_train, epochs=15, batch_size=8, validation_data=[x_test, y_test], callbacks=[es])

print(np.where(np.argmax(model.predict(x_test), axis=1) == np.argmax(y_test, axis=1), 1, 0).mean())

L'output è 0.74576, quindi trova correttamente il massimo 74,5% delle volte. Non ho dubbi sul fatto che ciò potrebbe essere migliorato, ma poiché dico che questo non è un caso d'uso, consiglierei per ML.

EDIT 2 : In realtà stamattina ho ripetuto di nuovo usando RandomForestClassifier di sklearn e ha funzionato significativamente meglio:

# instantiation of the arrays is identical

rfc = RandomForestClassifier(n_estimators=1000, verbose=1)
rfc.fit(x_train, y_train)

yhat_proba = rfc.predict_proba(x_test)


# We have some annoying transformations to do because this .predict_proba() call returns the data in a weird format of shape (20, 12500, 2).

for i in range(len(yhat_proba)):
    yhat_proba[i] = yhat_proba[i][:, 1]

pyhat = np.reshape(np.ravel(yhat_proba), (12500,20), order='F')

print(np.where(np.argmax(pyhat, axis=1) == np.argmax(y_test, axis=1), 1, 0).mean())

E il punteggio qui è il 94,4% dei campioni con il massimo identificato correttamente, il che è piuttosto buono.

Sì. Molto importante, decidi tu l'architettura di una soluzione di apprendimento automatico. Le architetture e le procedure di formazione non si scrivono da sole; devono essere progettati o modellati e la formazione segue come mezzo per scoprire una parametrizzazione dell'architettura adatta a un insieme di punti dati.

È possibile costruire un'architettura molto semplice che in realtà include una funzione massima:

net(x) = a * max(x) + b * min(x)

dove un e b sono apprese parametri.

Dati abbastanza campioni di allenamento e una ragionevole routine di allenamento, questa architettura molto semplice imparerà molto rapidamente a impostare a 1 e b a zero per il tuo compito.

L'apprendimento automatico spesso assume la forma di intrattenere molteplici ipotesi sulla featurization e la trasformazione dei punti di dati di input e di imparare a preservare solo quelle ipotesi correlate alla variabile target. Le ipotesi sono codificate esplicitamente nell'architettura e nelle sotto-funzioni disponibili in un algoritmo parametrizzato o come ipotesi codificate in un algoritmo "senza parametri".

Ad esempio, la scelta di usare prodotti a punti e non linearità come è comune nella rete neurale alla vaniglia ML è in qualche modo arbitraria; esprime l'ipotesi comprensiva che una funzione può essere costruita usando una struttura di rete compositiva predeterminata di trasformazioni lineari e funzioni di soglia. Diverse parametrizzazioni di quella rete incarnano ipotesi diverse su quali trasformazioni lineari usare. È possibile utilizzare qualsiasi toolbox di funzioni e il compito di uno studente di macchine è scoprire attraverso la differenziazione o la prova ed errore o qualche altro segnale ripetibile quali funzioni o caratteristiche nella sua matrice minimizzano al meglio una metrica di errore. Nell'esempio sopra riportato, la rete appresa si riduce semplicemente alla massima funzione stessa, mentre una rete indifferenziata potrebbe in alternativa "apprendere" una funzione minima. Queste funzioni possono essere espresse o approssimate con altri mezzi, come nella funzione di regressione della rete lineare o neurale in un'altra risposta. In breve, dipende davvero da quali funzioni o pezzi LEGO hai nella tua cassetta degli attrezzi dell'architettura ML.

Sì - L'apprendimento automatico può imparare a trovare il massimo in un elenco di numeri.

Ecco un semplice esempio di apprendimento per trovare l'indice del massimo:

import numpy as np
from sklearn.tree import DecisionTreeClassifier

# Create training pairs where the input is a list of numbers and the output is the argmax
training_data = np.random.rand(10_000, 5) # Each list is 5 elements; 10K examples
training_targets = np.argmax(input_data, axis=1)

# Train a descision tree with scikit-learn
clf = DecisionTreeClassifier()
clf.fit(input_data, targets)

# Let's see if the trained model can correctly predict the argmax for new data
test_data = np.random.rand(1, 5)
prediction = clf.predict(test_data)
assert prediction == np.argmax(test_data) # The test passes - The model has learned argmax

Algoritmi di apprendimento

Invece di apprendere una funzione come un calcolo fatto da una rete neurale feed-forward, c'è un intero dominio di ricerca riguardante gli algoritmi di apprendimento dai dati di esempio. Ad esempio, si potrebbe usare qualcosa come una Neural Turing Machine o qualche altro metodo in cui l'esecuzione di un algoritmo è controllata dall'apprendimento automatico nei suoi punti di decisione. Gli algoritmi giocattolo come trovare un massimo o ordinare un elenco, invertire un elenco o filtrare un elenco sono comunemente usati come esempi nella ricerca sull'apprendimento di algoritmi.

Escluderò i disegni educati dalla mia risposta. No, non è possibile utilizzare un fuori l'approccio machine learning scatola (ML) per pienamente rappresentare la funzione di massima per le arbitrarie liste con precisione arbitraria. ML è un metodo basato sui dati ed è chiaro che non sarai in grado di approssimare una funzione in regioni in cui non hai punti dati. Quindi, lo spazio di possibili osservazioni (che è infinito) non può essere coperto da osservazioni finite.

Le mie dichiarazioni hanno una base teorica con il Teorema di approssimazione universale di Cybeko per le reti neurali. Citerò il teorema di Wikipedia:

$\mathbb{R}^n$

$\mathbb{R}^n$$x\in \mathbb{R}$

Se il tuo spazio di osservazioni è compatto, potresti essere in grado di approssimare la funzione massima con un set di dati finito. Come la risposta più votata ha chiarito che non dovresti reinventare la ruota!

Ecco un'espansione sul mio commento. Per prefazione, assolutamente @DanScally ha ragione nel dire che non c'è motivo di usare ML per trovare un massimo di un elenco. Ma penso che il tuo "potrebbe darmi una comprensione di ciò che l'apprendimento automatico può fare in generale" è una buona ragione per approfondire questo.

$\max$$\max$

$\max$$\max$$\max$

$n$ $n$

$\operatorname{argmax}$$n$$\binom{n}{2}$$\delta_{ij} = \mathbf{1}(x_i < x_j)$$i<j$$x_j-x_i$$n$$x_i$$\sum_{j<i} \delta_{ji} + \sum_{j>i} (1-\delta_{ij})$$j$$x_i>x_j$$x_i$
$i$$i$

Infine, per la domanda successiva: possiamo addestrare un NN in questo stato. @DanScally ci ha fatto iniziare; forse conoscere l'architettura teorica può aiutarci a imbrogliare nella soluzione? (Si noti che se possiamo apprendere / approssimare il particolare insieme di pesi sopra, la rete effettivamente funzionerà ben al di fuori della gamma dei campioni di allenamento.)

Quaderno in github / Colab

$[-1,1]$ottiene il punteggio del test fino a 0,961, con un punteggio fuori range di 0,758. Ma sto segnando con lo stesso metodo di @DanScally, il che sembra un po 'disonesto: la funzione di identità avrà un punteggio perfetto su questa metrica. Ho anche stampato alcuni coefficienti per vedere se appare qualcosa di simile all'adattamento esatto sopra descritto (non proprio); e alcuni output non elaborati, che suggeriscono che il modello è troppo timido nel prevedere un massimo, errando sul lato della previsione che nessuno degli input è il massimo. Forse modificare l'obiettivo potrebbe aiutare, ma a questo punto ho già dedicato troppo tempo; se qualcuno si preoccupa di migliorare l'approccio, sentiti libero di giocare (se vuoi in Colab) e fammi sapere.

Sì, anche l'apprendimento automatico semplice quanto i minimi quadrati lineari ordinari può farlo se si utilizza una certa intelligenza applicata.

(Ma la maggior parte considererebbe questo eccessivo orribile).

(Presumo che vogliamo trovare il massimo degli addominali del vettore di input):

1. $$f(x) = \frac{1}{x^2}$$
2. $f({\bf r})$$\bf C_r$
3. $\bf S$
4. $(\epsilon {\bf I}+10^3{\bf S}^t{\bf S}+{\bf C_r})^{-1}(10^3 {\bf S}^t)$
5. $\bf p$ $$p_i = \frac{p_i^k}{\sum|p_i|^k}$$
6. Basta calcolare il prodotto scalare con il vettore indice e arrotondare.