Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

Rewrite this R code to Julia: library(parallel) library(foreach) library(doParallel)…

  1. User

    Rewrite this R code to Julia: library(parallel) library(foreach) library(doParallel) #"C:\Users\Michał\Desktop\player22.csv" Data<-read.csv("C:/Users/Użytkownik/Desktop/player22.csv")

    RW_idx <- which(grepl("RW", DataPositions))STidx<−which(grepl("ST",DataPositions)) ST_idx <- which(grepl("ST", DataPositions)) GK_idx <- which(grepl("GK", DataPositions))CMidx<−which(grepl("CM",DataPositions)) CM_idx <- which(grepl("CM", DataPositions)) LW_idx <- which(grepl("LW", DataPositions))CDMidx<−which(grepl("CDM",DataPositions)) CDM_idx <- which(grepl("CDM", DataPositions)) LM_idx <- which(grepl("LM", DataPositions))CFidx<−which(grepl("CF",DataPositions)) CF_idx <- which(grepl("CF", DataPositions)) CB_idx <- which(grepl("CB", DataPositions))CAMidx<−which(grepl("CAM",DataPositions)) CAM_idx <- which(grepl("CAM", DataPositions)) LB_idx <- which(grepl("LB", DataPositions))RBidx<−which(grepl("RB",DataPositions)) RB_idx <- which(grepl("RB", DataPositions)) RM_idx <- which(grepl("RM", DataPositions))LWBidx<−which(grepl("LWB",DataPositions)) LWB_idx <- which(grepl("LWB", DataPositions)) RWB_idx <- which(grepl("RWB", Data$Positions))

    c<-2 ############# a<-6/0

    position_vectors <- list(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)

    position_vectors_list<-position_vectors

    ##############

    Mutation 2

    mutate <- function(selected_players_df, position_vectors_list, probability) { n_rows <- nrow(selected_players_df) selected_players_matrix <- selected_players_df

    select_random_player <- function(idx_list, selected_players = NULL) { repeat { random_idx <- sample(idx_list, 1) if (!random_idx %in% selected_players) { return(random_idx) } } }

    for (i in 1:n_rows) { for (pos_idx in 1:length(position_vectors_list)) { if (runif(1) <= probability) { selected_players_matrix[i, pos_idx] <- select_random_player(position_vectors_list[[pos_idx]], selected_players = selected_players_matrix[i, ]) } } }

    selected_players_df <- data.frame(selected_players_matrix) return(selected_players_df) }

    n_rows<-100

    pop_init<- as.data.frame(matrix(NA, n_rows, length(position_vectors))) pop_init<- mutate(pop_init, position_vectors_list, probability=1)

    #######Target

    row1<-pop_init[1,]

    target <- function(row1,penalty=5) { position_ratings <- c("RWRating", "STRating", "GKRating", "CMRating", "LWRating", "CDMRating", "LMRating", "CFRating", "CBRating", "CAMRating", "LBRating", "RBRating", "RMRating", "LWBRating", "RWBRating")

    row1<-as.matrix(row1,nrow=1) parent_data <- Data[row1, ] ratings <- parent_data[position_ratings] ratings_log <- log(ratings)

    potential_minus_age <- 0.15*parent_dataPotential−0.6∗parentdataPotential - 0.6*parent_dataAge int_reputation <- parent_data$IntReputation

    sumratings<-0 rating_list<-c() for (i in 1:15){ temp<-ratings_log[i,i] sumratings<-sumratings+temp rating_list<-append(rating_list, temp)

    }

    Apply constraints

    constraint_penalty <- 0 if (sum(parent_dataValueEUR) > 250000000) { constraint_penalty <- constraint_penalty + log((sum(parent_dataValueEUR)-250000000)^penalty) } if (sum(parent_dataWageEUR) > 250000) { constraint_penalty <- constraint_penalty + log((sum(parent_dataWageEUR)-250000)^penalty) } if (any(rating_list < 1.2)) { constraint_penalty <- constraint_penalty + 1.2^penalty }

    potential_minus_age

    target_value <- -(sumratings+0.3*sum(potential_minus_age) +sum(int_reputation))+constraint_penalty

    return(target_value) }

    #target(global_best)

    parents<-pop_init t_size=2 penalty=1

    tournament_selection <- function(parents, t_size,penalty=6) { random_parents_idx <- sample(nrow(parents), t_size, replace = FALSE) random_parents <- parents[random_parents_idx, ]

    random_parents_fitness <- apply(random_parents, 1, function(x) target(x, penalty=penalty))

    best_parent_idx <- which.min(random_parents_fitness) return(random_parents[best_parent_idx, ]) }

    tournament_selection (pop_init,t_size=2)

    #best parent 1 #tournement_selection *50

    corssover_point<-6

    parent1<-row1 parent2<-pop_init[2,]

    crossover <- function(parent1, parent2,corssover_point) {

    offspring1 <- c(parent1[1:crossover_point], parent2[(crossover_point + 1):ncol(parent1)]) offspring2 <- c(parent2[1:crossover_point], parent1[(crossover_point + 1):ncol(parent2)])

    return(rbind(offspring1, offspring2))

    }

  2. Assistant
    using CSV, DataFrames
    using Random
    using Statistics
    
    Data = CSV.read("player22.csv", DataFrame)
    
    RW_idx = findall(occursin.("RW", Data.Positions))
    ST_idx = findall(occursin.("ST", Data.Positions))
    GK_idx = findall(occursin.("GK", Data.Positions))
    CM_idx = findall(occursin.("CM", Data.Positions))
    LW_idx = findall(occursin.("LW", Data.Positions))
    CDM_idx = findall(occursin.("CDM", Data.Positions))
    LM_idx = findall(occursin.("LM", Data.Positions))
    CF_idx = findall(occursin.("CF", Data.Positions))
    CB_idx = findall(occursin.("CB", Data.Positions))
    CAM_idx = findall(occursin.("CAM", Data.Positions))
    LB_idx = findall(occursin.("LB", Data.Positions))
    RB_idx = findall(occursin.("RB", Data.Positions))
    RM_idx = findall(occursin.("RM", Data.Positions))
    LWB_idx = findall(occursin.("LWB", Data.Positions))
    RWB_idx = findall(occursin.("RWB", Data.Positions))
    
    c = 2
    a = 6 / 0
    
    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]
    position_vectors_list = position_vectors
    
    function mutate(selected_players_df, position_vectors_list, probability)
        n_rows, _ = size(selected_players_df)
        selected_players_matrix = selected_players_df
    
        function select_random_player(idx_list, selected_players = Set{Integer}())
            while true
                random_idx = rand(idx_list)
                if !(random_idx in selected_players)
                    return random_idx
                end
            end
        end
    
        for i in 1:n_rows
            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 = selected_players_matrix[i, :])
                end
            end
        end
      
        selected_players_df = DataFrame(selected_players_matrix)
        return selected_players_df
    end
    
    n_rows = 100
    pop_init = DataFrame(fill(NA, n_rows, length(position_vectors)))
    pop_init = mutate(pop_init, position_vectors_list, probability=1)
    
    row1 = pop_init[1, :]
    
    function target(row, penalty=5)
        position_ratings = ["RWRating", "STRating", "GKRating", "CMRating",
                            "LWRating", "CDMRating", "LMRating", "CFRating",
                            "CBRating", "CAMRating", "LBRating", "RBRating",
                            "RMRating", "LWBRating", "RWBRating"]
      
        row = Matrix(row')
        parent_data = Data[row[1, :], :]
        ratings = Vector(parent_data[:, position_ratings])
        ratings_log = log.(ratings)
      
        potential_minus_age = 0.15 .* parent_data.Potential - 0.6 .* parent_data.Age
        int_reputation = parent_data.IntReputation
        rating_sum = sum(ratings_log)
        rating_list = sum(ratings_log, dims=1)
        
        constraint_penalty = 0
        if sum(parent_data.ValueEUR) > 250000000
            constraint_penalty += log((sum(parent_data.ValueEUR) - 250000000)^penalty)
        end
        if any(rating_list .< 1.2)
            constraint_penalty += 1.2^penalty
        end
      
        target_value = -(rating_sum + 0.3*sum(potential_minus_age) + sum(int_reputation)) + constraint_penalty
        return target_value
    end
    
    function tournament_selection(parents, t_size, penalty=6)
        random_parents_idx = rand(1:nrow(parents), t_size)
        random_parents = parents[random_parents_idx, :]
    
        random_parents_fitness = [target(x, penalty=penalty) for x in eachrow(random_parents)]
    
        best_parent_idx = argmin(random_parents_fitness)
        return random_parents[best_parent_idx, :]
    end
    
    crossover_point = 6
    parent1 = row1
    parent2 = pop_init[2, :]
    
    function crossover(parent1, parent2, corssover_point)
        offspring1 = [parent1[1:crossover_point]; parent2[(crossover_point + 1):size(parent1, 1)]]
        offspring2 = [parent2[1:crossover_point]; parent1[(crossover_point + 1):size(parent2, 1)]]
    
        return (offspring1, offspring2)
    end
    
  3. User

    using CSV, DataFrames using Random using Statistics

    Data = CSV.read("C:/Users/Użytkownik/Desktop/player22.csv", DataFrame)

    RW_idx = findall(occursin.("RW", Data.Positions)) ST_idx = findall(occursin.("ST", Data.Positions)) GK_idx = findall(occursin.("GK", Data.Positions)) CM_idx = findall(occursin.("CM", Data.Positions)) LW_idx = findall(occursin.("LW", Data.Positions)) CDM_idx = findall(occursin.("CDM", Data.Positions)) LM_idx = findall(occursin.("LM", Data.Positions)) CF_idx = findall(occursin.("CF", Data.Positions)) CB_idx = findall(occursin.("CB", Data.Positions)) CAM_idx = findall(occursin.("CAM", Data.Positions)) LB_idx = findall(occursin.("LB", Data.Positions)) RB_idx = findall(occursin.("RB", Data.Positions)) RM_idx = findall(occursin.("RM", Data.Positions)) LWB_idx = findall(occursin.("LWB", Data.Positions)) RWB_idx = findall(occursin.("RWB", Data.Positions))

    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] position_vectors_list = position_vectors

    function mutate(selected_players_df, position_vectors_list, probability) n_rows, _ = size(selected_players_df) selected_players_matrix = copy(selected_players_df)

    function select_random_player(idx_list, selected_players)
        while true
            random_idx = rand(idx_list)
            if !(ismissing(selected_players[random_idx]))
                return random_idx
            end
        end
    end
    
    for i in 1:n_rows
        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
    
    selected_players_df = DataFrame(selected_players_matrix)
    return selected_players_df
    

    end

    n_rows = 100 pop_init = DataFrame([Vector{Union{Missing, Float64}}(missing, n_rows) for _ in 1:length(position_vectors)], unique(Data[!, "BestPosition"])) pop_init = mutate(pop_init, position_vectors_list, 1) row1 = pop_init[1, :]

    function target(row, penalty=5) position_ratings = ["RWRating", "STRating", "GKRating", "CMRating", "LWRating", "CDMRating", "LMRating", "CFRating", "CBRating", "CAMRating", "LBRating", "RBRating", "RMRating", "LWBRating", "RWBRating"]

    row = Matrix(row')
    parent_data = Data[row[1, :], :]
    ratings = Vector(parent_data[:, position_ratings])
    ratings_log = log.(ratings)
    
    potential_minus_age = 0.15 .* parent_data.Potential - 0.6 .* parent_data.Age
    int_reputation = parent_data.IntReputation
    rating_sum = sum(ratings_log)
    rating_list = sum(ratings_log, dims=1)
    
    constraint_penalty = 0
    if sum(parent_data.ValueEUR) > 250000000
        constraint_penalty += log((sum(parent_data.ValueEUR) - 250000000)^penalty)
    end
    if any(rating_list .< 1.2)
        constraint_penalty += 1.2^penalty
    end
    
    target_value = -(rating_sum + 0.3*sum(potential_minus_age) + sum(int_reputation)) + constraint_penalty
    return target_value
    

    end

    function tournament_selection(parents, t_size, penalty=6) random_parents_idx = rand(1:nrow(parents), t_size) random_parents = parents[random_parents_idx, :]

    random_parents_fitness = [target(x, penalty=penalty) for x in eachrow(random_parents)]
    
    best_parent_idx = argmin(random_parents_fitness)
    return random_parents[best_parent_idx, :]
    

    end

    crossover_point = 6 parent1 = row1 parent2 = pop_init[2, :]

    function crossover(parent1, parent2, corssover_point) offspring1 = [parent1[1:crossover_point]; parent2[(crossover_point + 1):size(parent1, 1)]] offspring2 = [parent2[1:crossover_point]; parent1[(crossover_point + 1):size(parent2, 1)]] return (offspring1, offspring2) end

    and error: BoundsError: attempt to access data frame with 15 columns at index [11417]

    Stacktrace: [1] getindex @ C:\Users\Użytkownik.julia\packages\DataFrames\LteEl\src\other\index.jl:193 [inlined] [2] parentcols @ C:\Users\Użytkownik.julia\packages\DataFrames\LteEl\src\other\index.jl:463 [inlined] [3] getindex @ C:\Users\Użytkownik.julia\packages\DataFrames\LteEl\src\dataframerow\dataframerow.jl:212 [inlined] [4] (::var"#select_random_player#27")(idx_list::Vector{Int64}, selected_players::DataFrameRow{DataFrame, DataFrames.Index}) @ Main .\In[9]:37 [5] mutate(selected_players_df::DataFrame, position_vectors_list::Vector{Vector{Int64}}, probability::Int64) @ Main .\In[9]:46 [6] top-level scope @ In[9]:58

  4. Assistant

    I can see that you are trying to access the index 11417 in your DataFrame, but it only has 15 columns. If you are working with a full-fledged example, it's very likely that the error is caused by the select_random_player function. To fix this, I would need to review the original dataset and understand the intentions of the original R code. However, for now, I can provide a slightly modified version of the code to avoid this error:

    function mutate(selected_players_df, position_vectors_list, probability)
        n_rows, _ = size(selected_players_df)
        selected_players_matrix = copy(selected_players_df)
    
        function select_random_player(idx_list, selected_players)
            available_indices = filter(x -> !ismissing(selected_players[x]), idx_list)
            return rand(available_indices)
        end
    
        for i in 1:n_rows
            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
    
        selected_players_df = DataFrame(selected_players_matrix)
        return selected_players_df
    end
    

    This modification adds a filter to the select_random_player function that should make sure you don't access missing values in the selected players. Please note that this might not be the most efficient solution, and it would be a good idea to revisit this after understanding the dataset and the original R code more thoroughly.