As amostras de treinamento coletadas aleatoriamente para redes neurais de treinamento em mini-lotes devem ser coletadas sem substituição?

Definimos uma época como tendo passado por todas as amostras de treinamento disponíveis, e o tamanho do minilote como o número de amostras sobre as quais calculamos a média para encontrar as atualizações de pesos / desvios necessários para descer o gradiente.

Minha pergunta é se devemos extrair sem substituição do conjunto de exemplos de treinamento para gerar cada mini lote dentro de uma época. Sinto que devemos evitar a substituição para garantir que realmente "colamos todas as amostras" para atender ao requisito de fim de época, mas estou tendo problemas para encontrar uma resposta definitiva de uma maneira ou de outra.

Eu tentei pesquisar no Google e ler o cap. Uma das redes neurais e aprendizagem profunda da Nielsen, mas não encontrou uma resposta clara. Nesse texto, Nielsen não especifica que a amostragem aleatória seja feita sem substituição, mas parece implicar que sim.

Uma formalização mais clara do treinamento em épocas pode ser encontrada aqui, se desejado - /stats//a/141265/131630

Edit: esta pergunta parecia semelhante a mim, mas não estava claro como aplicar o fato de que a linearidade da expectativa é indiferente à independência nessa situação - a amostragem deve ocorrer com ou sem substituição

Uma boa análise teórica de esquemas com e sem substituição no contexto de algoritmos iterativos baseados em sorteios aleatórios (que são contra as quais redes neurais profundas discriminativas (DNNs) são treinadas) pode ser encontrada aqui

Em resumo, a amostragem sem substituição leva a uma convergência mais rápida do que a amostragem com substituição.

Vou fazer uma breve análise aqui, com base no exemplo de brinquedo que eles fornecem: Digamos que queremos otimizar a seguinte função objetivo:

$$x_{\text{opt}} = \underset{x}{\arg\min} \frac{1}{2} \sum_{i=1}^{N}(x - y_i)^2$$

onde o destino . Neste exemplo, estamos tentando resolver o ideal , considerando rótulos de obviamente.x N y $y_i \sim \mathcal{N}(\mu, \sigma^2)$$x$$N$$y_i$

Ok, então, se resolvermos o ideal acima, diretamente, pegaremos a derivada da função loss aqui, configurá-la para 0 e resolver . Portanto, para o nosso exemplo acima, a perda é$x$$x$

$$L = \frac{1}{2} \sum_{i=1}^{N}(x - y_i)^2$$

e sua primeira derivada seria:

$$\frac{\delta L}{\delta x} = \sum_{i=1}^{N}(x - y_i)$$

Definir como 0 e resolver , produz:$\frac{\delta L}{\delta x}$$x$

$$x_{\text{opt}} = \frac{1}{N} \sum_{i=1}^{N} y_i$$

Em outras palavras, a solução ideal nada mais é do que a média da amostra de todas as amostras de .$N$$y$

Agora, se não pudéssemos executar o cálculo acima de uma só vez, teríamos que fazê-lo recursivamente, através da equação de atualização de descida do gradiente abaixo:

$$x_i = x_{i-1} - \lambda_i \nabla(f(x_{i-1}))$$

e simplesmente inserir nossos termos aqui produz:

$$x_{i} = x_{i-1} - \lambda_i (x_{i-1} - y_{i})$$

Se executarmos o acima para todos os , estamos efetivamente executando esta atualização sem substituição. A questão então se torna: podemos obter também o valor ideal de dessa maneira? (Lembre-se de que o valor ideal de nada mais é do que a média da amostra de ). A resposta é sim, se você deixar . Para ver, expandimos: x x y λ i = 1 /$i \in {1, 2, ... N}$$x$$x$$y$$\lambda_i = 1/i$

$$x_{i} = x_{i-1} - \lambda_i (x_{i-1} - y_{i}) \\\ x_{i} = x_{i-1} - \frac{1}{i} (x_{i-1} - y_{i}) \\\ x_{i} = \frac{i x_{i-1} - (x_{i-1} - y_{i})}{i} \\\ x_{i} = \frac{(i - 1)x_{i-1} + y_{i}}{i} \\\ i x_{i} = (i - 1)x_{i-1} + y_{i} \\\ $$

A última equação, no entanto, nada mais é do que a fórmula para a média corrente! Assim, ao percorrermos o conjunto de , , etc, até , teríamos realizado nossas atualizações sem substituição, e nossa fórmula de atualização nos fornece a solução ideal de , que é a média da amostra!$i=1$$i=2$$i=N$$x$

$$N x_{N} = (N - 1)x_{N-1} + y_{N} ==> x_N = \frac{1}{N}\sum_{i=1}^{N} y_i = \mu$$

Por outro lado, no entanto, se realmente empatássemos com a substituição, embora nossos empates fossem verdadeiramente independentes, o valor otimizado seria diferente da média (ótima) , e o erro quadrado seria dado por:$x_N$$\mu$

$$\mathop{E}\{(x_N - \mu)^2\}$$

que será um valor positivo, e este exemplo simples de brinquedo pode ser estendido para dimensões mais altas. Isso tem a conseqüência de que gostaríamos de realizar amostragens sem substituição como uma solução mais ideal.

Espero que isso esclareça um pouco mais!

De acordo com o código no repositório da Nielsen, mini-lotes são sorteados sem substituição:

    def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None):
    n = len(training_data)
    for j in range(epochs):
            random.shuffle(training_data)
            mini_batches = [
                training_data[k:k+mini_batch_size]
                for k in range(0, n, mini_batch_size)
            ]
            for mini_batch in mini_batches:
                self.update_mini_batch(mini_batch, eta)

Podemos ver que não há substituição de amostras de treinamento em uma época. Curiosamente, também podemos ver que a Nielsen opta por não se preocupar em ajustar eta(a taxa de aprendizado) para o último tamanho de mini-lote, que pode não ter tantas amostras de treinamento quanto os mini-lotes anteriores. Presumivelmente, essa é uma modificação avançada que ele deixa para os capítulos posteriores. **

** EDIT: Na verdade, esse dimensionamento ocorre na def update_mini_batchfunção. Por exemplo, com os pesos:

self.weights = [w-(eta/len(mini_batch))*nw for w, nw in zip(self.weights, nabla_w)]     

Isso é necessário porque o último mini_batch pode ser menor que o mini_batch anterior, se o número de amostras de treinamento por mini_batch não se dividir uniformemente no número total de amostras de treinamento disponíveis.

mylist = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
n = len(mylist)
mini_batch_size = 2
mini_batches = [
    mylist[k:k+mini_batch_size]
    for k in range(0, n, mini_batch_size)
    ]
for mini_batch in mini_batches:
    print(mini_batch)

Resultado:

['1', '2']
['3', '4']
['5', '6']
['7', '8']
['9', '10']

Mudando mini_batch_sizepara 3, que não se divide uniformemente em nossas 10 amostras de treinamento. Para saída, obtemos:

['1', '2', '3']
['4', '5', '6']
['7', '8', '9']
['10']

Ao avaliar uma faixa sobre os índices da lista (algo da forma [x:y]onde xe ysão alguns índices na lista), se o nosso valor da mão direita excede o comprimento lista, python simplesmente retorna os itens da lista até o valor sai da faixa de índice .

Portanto, o último mini-lote pode ser menor que os mini-lotes anteriores, mas se for ponderado pelo mesmo eta, as amostras de treinamento contribuirão mais para o aprendizado do que as amostras nos outros mini-lotes maiores. Como este é apenas o último mini-lote, provavelmente não vale a pena se preocupar muito, mas pode ser facilmente resolvido escalando etapara a duração do mini-lote.