Module: Cnvrg::Helpers

Extended by:

Helpers

Included in:

Helpers

Defined in:

lib/cnvrg/helpers.rb

Instance Method Summary

• #checkmark ⇒ Object
• #cnvrgignore_content ⇒ Object
• #cpu_time ⇒ Object

  cpu.

• #decrypt(key, iv, str) ⇒ Object
• #get_mem(pid) ⇒ Object

  memory.

• #get_s3_props(files) ⇒ Object

  will return client and decryptor.

• #hyper_content ⇒ Object
• #internet_connection? ⇒ Boolean
• #is_verify_ssl ⇒ Object
• #linux? ⇒ Boolean
• #look_for_in_path(path, name) ⇒ Object
• #mac? ⇒ Boolean
• #netrc_domain ⇒ Object
• #os ⇒ Object
• #parallel_threads ⇒ Object
• #readme_content ⇒ Object
• #remote_url ⇒ Object
• #ubuntu? ⇒ Boolean
• #wall_time ⇒ Object
• #windows? ⇒ Boolean

Instance Method Details

#checkmark ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 9

def checkmark
  checkmark = "\u2713"
  return checkmark.encode('utf-8')
end

#cnvrgignore_content ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 96

def cnvrgignore_content
  %{
# cnvrg ignore: Ignore the following directories and files
# for example:
# some_dir/
# some_file.txt
.git*
.gitignore
        }.strip
end

#cpu_time ⇒ Object

cpu

# File 'lib/cnvrg/helpers.rb', line 189

def cpu_time
  Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID, :microsecond)
end

#decrypt(key, iv, str) ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 197

def decrypt(key,iv,str)
  begin
  cipher = OpenSSL::Cipher.new("aes-256-cbc").decrypt
  cipher.key = key
  cipher.iv = Base64.decode64 iv.encode('ascii-8bit')

  result = Base64.decode64 (str.encode('ascii-8bit'))
  result = cipher.update(result)
  result << cipher.final

  return result
  rescue => e
    puts e


  end


end

#get_mem(pid) ⇒ Object

memory

# File 'lib/cnvrg/helpers.rb', line 219

def get_mem(pid)
end

#get_s3_props(files) ⇒ Object

will return client and decryptor

# File 'lib/cnvrg/helpers.rb', line 222

def get_s3_props(files) #will return client and decryptor
  sts_path = files["path_sts"]
  retries = 0
  success= false
  while !success and retries < 20
    begin
      if !Helpers.is_verify_ssl
        body = open(sts_path, {ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE}).read
      else
        body = open(sts_path).read
      end
      success = true
    rescue => e
      retries +=1
      sleep(5)

    end
  end
  if !success
    return Cnvrg::Result.new(false,"couldn't download some files", "error in sts", "" )
  end
  split = body.split("\n")
  key = split[0]
  iv = split[1]

  access =  Cnvrg::Helpers.decrypt(key, iv, files["sts_a"])

  secret =  Cnvrg::Helpers.decrypt(key,iv, files["sts_s"])

  session =  Cnvrg::Helpers.decrypt(key,iv, files["sts_st"])
  region =  Cnvrg::Helpers.decrypt(key,iv, files["region"])

  bucket =  Cnvrg::Helpers.decrypt(key,iv, files["bucket"])
  is_s3 = files["is_s3"]
  if is_s3 or is_s3.nil?
    client = Aws::S3::Client.new(
        :access_key_id =>access,
        :secret_access_key => secret,
        :session_token => session,
        :region => region,
        :http_open_timeout => 60, :retry_limit => 20)
    use_accelerate_endpoint = true
  else
    endpoint = Cnvrg::Helpers.decrypt(key,iv, files["endpoint_url"])
    client = Aws::S3::Client.new(
        :access_key_id =>access,
        :secret_access_key => secret,
        :region => region,
        :endpoint=> endpoint,:force_path_style=> true,:ssl_verify_peer=>false,
        :http_open_timeout => 60, :retry_limit => 20)
    use_accelerate_endpoint = false
  end
  upload_options = {:use_accelerate_endpoint => use_accelerate_endpoint,:server_side_encryption => 'AES256'}
  return {client: client, key: key, iv: iv, bucket: bucket, upload_options: upload_options}
end

#hyper_content ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 107

def hyper_content
  %{# Hyperparameter Optimization is the process of choosing a set of parameters for a learning algorithm, usually with the goal of optimizing a measure of the algorithm's performance on an independent data set.

# Below is the list of parameters that will be used in the optimization process. Each parameter has a param_name that should match the argument that is feeded to the experiment s.t kernel => --kernel='rbf'

parameters:
  # Integer parameter is a range of possible values between a minimum (inclusive)
  # and maximum (not inclusive) values. Values are floored (0.7 => 0)
- param_name: "learning_rate"
  type: "integer" 
  min: 0 # inclusive
  max: 10 # not inclusive
  scale: "linear"
  steps: 4 # The number of linear steps to produce.


# Float parameter is a range of possible values between a minimum (inclusive)
# and maximum (not inclusive) values.
#
- param_name: "learning_rate"
  type: "float" # precision is 9 after period
  min: 0.00001
  max: 0.1
  scale: "log2" # Could be log10 as well
  steps: 2

# Discrete parameter is an array of numerical values.
#
- param_name: "c"
  type: "discrete"
  values: [0, 0.1 ,0.001]

# Categorical parameter is an array of string values
#
- param_name: "kernel"
  type: "categorical"
  values: ["linear", "poly", "rbf"] 

}
end

#internet_connection? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/cnvrg/helpers.rb', line 14

def internet_connection?
  begin
    true if open("http://www.google.com/")
  rescue
    false
  end
end

#is_verify_ssl ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 41

def is_verify_ssl
  home_dir = File.expand_path('~')
  config = ""
  begin
    if File.exist? home_dir+"/.cnvrg/config.yml"
      config = YAML.load_file(home_dir+"/.cnvrg/config.yml")
    else
     return true

    end

  rescue
    return true
  end
  if !config or config.empty? or config.to_h[:verify_ssl].nil?
    return true
  else
    return config.to_h[:verify_ssl]
  end
end

#linux? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/cnvrg/helpers.rb', line 87

def linux?
  not mac? and not windows?
end

#look_for_in_path(path, name) ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 177

def look_for_in_path(path, name)
  url_split = path.split("/")
  url_split.each_with_index do |u, i|
    if u == name
      return i
    end
  end
  return -1
end

#mac? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/cnvrg/helpers.rb', line 83

def mac?
  !!(RUBY_PLATFORM =~ /-darwin\d/)
end

#netrc_domain ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 173

def netrc_domain
  "cnvrg.io"
end

#os ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 62

def os

  if windows?
    return "windows"
  elsif mac?
    return "mac"
  elsif ubuntu?
    return "ubuntu"
  elsif linux?

    return "linux"
  else

    return "N/A"
  end
end

#parallel_threads ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 6

def parallel_threads()
  return ParallelThreads
end

#readme_content ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 148

def readme_content
  %{
        # README

        This README would normally contain some context and description about the project. 

        Things you may want to cover:

        * Data description

        * Benchmark and measurement guidelines

        * Used algorithms

        * Scores

        * Configurations

        * Requirements

        * How to run the experiments

        * ...}.strip
end

#remote_url ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 22

def remote_url
  home_dir = File.expand_path('~')
  config = ""
  begin
    if File.exist? home_dir+"/.cnvrg/config.yml"
      config = YAML.load_file(home_dir+"/.cnvrg/config.yml")
    else
      return "https://cnvrg.io"
    end

  rescue
    return "https://cnvrg.io"
  end
  if !config or config.empty? or config.to_h[:api].nil?
    return "https://cnvrg.io"
  else
    return config.to_h[:api].gsub("/api", "")
  end
end

#ubuntu? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/cnvrg/helpers.rb', line 91

def ubuntu?
  unix = `cat /etc/lsb-release`.downcase!
  return unix.include? "ubuntu"
end

#wall_time ⇒ Object

# File 'lib/cnvrg/helpers.rb', line 193

def wall_time
  Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
end

#windows? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/cnvrg/helpers.rb', line 79

def windows?
  !!(RUBY_PLATFORM =~ /mswin32|mingw32/)
end