This Julia code:
using BenchmarkTools, Distributed
addprocs()
@everywhere using DataFrames, CSV, DataFrames, Random, StatsBase, LinearAlgebra
@everywhere Data = CSV.read("C:/Users/Użytkownik/Desktop/player22.csv", DataFrame)

# Indices of players for each position
@everywhere  RW_idx = findall(x -> occursin("RW", x), Data[!, :Positions])
@everywhere  ST_idx = findall(x -> occursin("ST", x), Data[!, :Positions])
@everywhere GK_idx = findall(x -> occursin("GK", x), Data[!, :Positions])
@everywhere CM_idx = findall(x -> occursin("CM", x), Data[!, :Positions])
@everywhere LW_idx = findall(x -> occursin("LW", x), Data[!, :Positions])
@everywhere CDM_idx = findall(x -> occursin("CDM", x), Data[!, :Positions])
@everywhere LM_idx = findall(x -> occursin("LM", x), Data[!, :Positions])
@everywhere CF_idx = findall(x -> occursin("CF", x), Data[!, :Positions])
@everywhere CB_idx = findall(x -> occursin("CB", x), Data[!, :Positions])
@everywhere CAM_idx = findall(x -> occursin("CAM", x), Data[!, :Positions])
@everywhere LB_idx = findall(x -> occursin("LB", x), Data[!, :Positions])
@everywhere RB_idx = findall(x -> occursin("RB", x), Data[!, :Positions])
@everywhere RM_idx = findall(x -> occursin("RM", x), Data[!, :Positions])
@everywhere LWB_idx = findall(x -> occursin("LWB", x), Data[!, :Positions])
@everywhere RWB_idx = findall(x -> occursin("RWB", x), Data[!, :Positions])
@everywhere position_vectors = [RW_idx, ST_idx, GK_idx, CM_idx, LW_idx,
                    CDM_idx, LM_idx, CF_idx, CB_idx, CAM_idx,
                    LB_idx, RB_idx, RM_idx, LWB_idx, RWB_idx]
					
@everywhere using DataFrames

@everywhere function create_ones_dataframe(n_rows, length_position_vectors)
    position_vectors = fill(1, length_position_vectors)
    df = DataFrame()
    for i in 1:length_position_vectors
        col_name = Symbol("Position_$i")
        df[!, col_name] = position_vectors
    end
    return repeat(df, n_rows)
end

@everywhere n_rows = 20

@everywhere pop_init = create_ones_dataframe(n_rows, length(position_vectors))
@everywhere n_rows=100
@everywhere pop_init= pop_init[1:(n_rows), :]
     
@everywhere function mutate(selected_players, position_vectors_list, probability)
    selected_players_matrix = copy(selected_players)

    function select_random_player(idx_list, selected_players)
        while true
            random_idx = rand(idx_list)
            if ismissing(selected_players) || !(random_idx in selected_players)
                return random_idx
            end
        end
    end



    for i in 1:size(selected_players_matrix)[1]
        for pos_idx in 1:length(position_vectors_list)
            if rand() <= probability
                selected_players_matrix[i, pos_idx] = select_random_player(position_vectors_list[pos_idx],
                                                                           selected_players_matrix[i, :])
            end
        end
    end

    return convert(DataFrame, selected_players_matrix)
end

@everywhere n_rows = 100
@everywhere pop_init = mutate(pop_init, position_vectors,1.0)




@everywhere function crossover(parent1, parent2, crossover_point=6)
    
    
    
    offspring1 = hcat(DataFrame(parent1[1:crossover_point]), DataFrame(parent2[(crossover_point + 1):end]))
    offspring2 = hcat(DataFrame(parent2[1:crossover_point]), DataFrame(parent1[(crossover_point + 1):end]))

    return vcat(offspring1,offspring2)
end

@everywhere function target2(row, penalty=5,weight1=0.15,weight2=0.6,weight3=0.3,contraint_1=250000000,constraint2=250000,contraint_3=1.2)
    position_ratings = ["RWRating", "STRating", "GKRating", "CMRating",
                        "LWRating", "CDMRating", "LMRating", "CFRating",
                        "CBRating", "CAMRating", "LBRating", "RBRating",
                        "RMRating", "LWBRating", "RWBRating"]
    parent_data = DataFrame(ID=Int[], Name=String[], FullName=String[], Age=Int[], Height=Int[], Weight=Int[], PhotoUrl=String[], Nationality=String[], Overall=Int[], Potential=Int[], Growth=Int[], TotalStats=Int[], BaseStats=Int[], Positions=String[], BestPosition=String[], Club=String[], ValueEUR=Int[], WageEUR=Int[], ReleaseClause=Int[], ClubPosition=String[], ContractUntil=String[], ClubNumber=Int[], ClubJoined=Int[], OnLoad=Bool[], NationalTeam=String[], NationalPosition=String[], NationalNumber=Int[], PreferredFoot=String[], IntReputation=Int[], WeakFoot=Int[], SkillMoves=Int[], AttackingWorkRate=String[], DefensiveWorkRate=String[], PaceTotal=Int[], ShootingTotal=Int[], PassingTotal=Int[], DribblingTotal=Int[], DefendingTotal=Int[], PhysicalityTotal=Int[], Crossing=Int[], Finishing=Int[], HeadingAccuracy=Int[], ShortPassing=Int[], Volleys=Int[], Dribbling=Int[], Curve=Int[], FKAccuracy=Int[], LongPassing=Int[], BallControl=Int[], Acceleration=Int[], SprintSpeed=Int[], Agility=Int[], Reactions=Int[], Balance=Int[], ShotPower=Int[], Jumping=Int[], Stamina=Int[], Strength=Int[], LongShots=Int[], Aggression=Int[], Interceptions=Int[], Positioning=Int[], Vision=Int[], Penalties=Int[], Composure=Int[], Marking=Int[], StandingTackle=Int[], SlidingTackle=Int[], GKDiving=Int[], GKHandling=Int[], GKKicking=Int[], GKPositioning=Int[], GKReflexes=Int[], STRating=Int[], LWRating=Int[], LFRating=Int[], CFRating=Int[], RFRating=Int[], RWRating=Int[], CAMRating=Int[], LMRating=Int[], CMRating=Int[], RMRating=Int[], LWBRating=Int[], CDMRating=Int[], RWBRating=Int[], LBRating=Int[], CBRating=Int[], RBRating=Int[], GKRating=Int[])
    for i in row
        row_indices = Data[i, :]
        parent_data=vcat(parent_data,row_indices)
    end
    parent_data=DataFrame(parent_data[2:16])
    ratings = parent_data[:, position_ratings]
    ratings_log = log.(ratings)
    
    potential_minus_age = weight1 * parent_data.Potential - weight2 * parent_data.Age
    int_reputation = parent_data.IntReputation
    sumratings = []
    for i in 1:15
        temp=ratings_log[i,i]
        push!(sumratings, temp)
    end
    
    rating_list=sumratings
    sumratings=sum(sumratings)
    
    # Apply constraints
    constraint_penalty = 0
    if sum(parent_data.ValueEUR) > contraint_1
        constraint_penalty += log((sum(parent_data.ValueEUR) - contraint_1)) ^ penalty
    end
    if sum(parent_data.WageEUR) > constraint2
        constraint_penalty += log((sum(parent_data.WageEUR) - constraint2)) ^ penalty
    end
    if any(rating_list .< contraint_3)
        constraint_penalty += contraint_3 ^ penalty
    end

    target_value = -(sumratings + weight3 * sum(potential_minus_age) + sum(int_reputation)) + constraint_penalty
    return target_value
end
     
@everywhere weight1=0.15
@everywhere weight2=0.6
@everywhere weight3=0.3
@everywhere contraint_1=250000000
@everywhere constraint2=250000
@everywhere contraint_3=1.2

@everywhere function tournament_selection2(parents, t_size, penalty=6,nrows=100,weight1=0.15,weight2=0.6,weight3=0.3,contraint_1=250000000,constraint2=250000,contraint_3=1.2)
    random_parents = unique(parents[shuffle(1:size(parents, 1)), :])[1:2, :]

    random_parents_fitness = [target2(parent, penalty,weight1,weight2,weight3,contraint_1,constraint2,contraint_3) for parent in eachrow(random_parents)]

    best_parent_idx = argmin(random_parents_fitness)
    return random_parents[best_parent_idx, :]
end
     
@everywhere function GA2(crossover_point=7, population_size=100, num_generations=10, tournament_size=2, probability=0.09, weight1=0.15,
weight2=0.6,
weight3=0.3,
contraint_1=250000000,
constraint2=250000,
contraint_3=1.2)
    
    nrows=population_size
    parents = mutate(pop_init, position_vectors, 1.0)
    global_best = pop_init[1, :]
    global_best_value = target2(global_best,6,weight1,weight2,weight3,contraint_1,constraint2,contraint_3)
    penalty=1
    # Main loop
    for gen in 1:num_generations
        # Parent population
        parent_pop = create_ones_dataframe(n_rows, length(position_vectors))
        parent_pop = parent_pop[1:n_rows, :]
        for c in 1:population_size
            parent_pop[c, :] = tournament_selection2(parents, tournament_size, penalty,weight1,weight2,weight3,contraint_1,constraint2,contraint_3)
        end

        # Generate offspring
        offspring_temp = create_ones_dataframe(n_rows, length(position_vectors))
        offspring_temp = offspring_temp[1:n_rows, :]
        for c in 1:2:population_size
            offsprings = crossover(parent_pop[c, :], parent_pop[c + 1, :], crossover_point)
            offspring_temp = vcat(offspring_temp, offsprings)
        end
        offspring_temp = offspring_temp[nrows+1:end, :]

        parents = mutate(offspring_temp, position_vectors, 0.09)

        # Evaluate solutions
        solutions = [target2(parent,6,weight1,weight2,weight3,contraint_1,constraint2,contraint_3) for parent in eachrow(parents)]
        idx_sol = argmin(solutions)
        temp_best = parents[idx_sol, :]
        temp_target_value = solutions[idx_sol]
        
        if penalty==4
            penalty=0
        else
            penalty+0.5
        end
        
        if temp_target_value <= global_best_value
            global_best = temp_best
            global_best_value = temp_target_value
        end
    end

    return global_best, global_best_value
end


function parallel_processing()
    weight1_range = 0.05:0.05:0.2
    weight2_range = 0:0.1:1.0
    weight3_range = 0.1:0.1:0.9

    params = [(weight1, weight2, weight3) for weight1 in weight1_range, weight2 in weight2_range, weight3 in weight3_range]
    params = vec(params)

    function process_weights(weights)
        weight1, weight2, weight3 = weights
        global_best, global_best_value = GA2(7, 100, 5000, 2, 0.09, weight1, weight2, weight3, 250000000, 250000, 1.2)
        global_best_df = DataFrame(global_best)
        return (weight1=weight1, weight2=weight2, weight3=weight3, global_best=global_best_df, global_best_value=global_best_value)
    end

    results = pmap(process_weights, params)

    df_results = DataFrame(weight1 = Float64[], weight2 = Float64[], weight3 = Float64[], global_best = Any[], global_best_value = Any[])

    for r in results
        push!(df_results, r)
    end

    return df_results
end
k=parallel_processing()
    
WORKS TOO FUCKING SLOW. Optimize it.  Write whole code, be focused on details. Remeber, the key of this code is to check the response of     weight1_range = 0.05:0.05:0.2
    weight2_range = 0:0.1:1.0
    weight3_range = 0.1:0.1:0.9 on genetic algorithm (here GA2 function).