# Stochastic gradient descent

**URL:** <https://discourse.julialang.org/t/stochastic-gradient-descent/42642>\
**Category:** General Usage\
**Tags:** question, machine-learning\
**Created:** [July 6, 2020, 9:32pm UTC](https://discourse.julialang.org/t/stochastic-gradient-descent/42642 "2020-07-06T21:32:19Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![A.U.M](https://avatars.discourse-cdn.com/v4/letter/a/aeb1de/32.png) [@A.U.M](https://discourse.julialang.org/u/A.U.M)\
**Post date:** [July 6, 2020, 9:32pm UTC](https://discourse.julialang.org/t/stochastic-gradient-descent/42642/1 "2020-07-06T21:32:20Z")

</div>

Hello, I am working on implementing a function SGD ( Stochastic gradient descent )  
I did it like the following but I want to Parallelize the for loop over all batches in the function in an optimum way can anyone help?

```julia
function SGD(nn::Network,
        training_data_x::Vector{Vector{Float64}},
        training_data_y::Vector{Vector{Float64}},
        epochs::Int, batch_size::Int, eta::Float64,
        lambda::Float64 = 0.0;
        validation_data_x::Vector{Vector{Float64}} = [],
        validation_data_y::Union{Vector{Int64}, Vector{Vector{Float64}}} = [],
        monitor_training_cost = true,
        monitor_validation_cost = true,
        monitor_training_accuracy = true,
        monitor_validation_accuracy = true)
    nn.training_cost = []
    nn.validation_cost = []
    nn.training_accuracy = []
    nn.validation_accuracy = []
    
for epoch in 1:epochs
        local perm = Random.randperm(length(training_data_x))
        for k in 1:batch_size:length(training_data_x)
            update!(nn,
                training_data_x[perm[k:min(k+batch_size‑1, end)]],
                training_data_y[perm[k:min(k+batch_size‑1, end)]],
                eta, lambda, length(training_data_x))
        end
        
        @info @Printf.sprintf("Epoch %d done", epoch)
        if monitor_training_cost
            push!(nn.training_cost,
                total_cost(nn, training_data_x, training_data_y, lambda))
            @info @Printf.sprintf("Cost on training data: %f",
                nn.training_cost[end])
        end
        if monitor_validation_cost
            push!(nn.validation_cost,
                total_cost(nn, validation_data_x, validation_data_y, lambda))
            @info @Printf.sprintf("Cost on validation data: %f",
                nn.validation_cost[end])
        end
        
        if monitor_training_accuracy
            local a = accuracy(nn, training_data_x, training_data_y)
            local l = length(training_data_x)
            local r = a/l
            @info @Printf.sprintf("Accuracy on training data: %5d / %5d = %5.1f%% correct",
                a, l, 100*r)
            push!(nn.training_accuracy, r)
        end
        
        if monitor_validation_accuracy
            local a = accuracy(nn, validation_data_x, validation_data_y)
            local l = length(validation_data_x)
            local r = a/l
            @info @Printf.sprintf("Accuracy on validation data: %5d / %5d = %5.1f%% correct",
                a, l, 100*r)
            push!(nn.validation_accuracy, r)
        end
    end
    nn
end

```