예제 #1
0
 def _cluster_info():
     global __H2OCONN__
     cld = __H2OCONN__._cld
     # self._session_id = self.get_session_id()
     ncpus = sum([n['num_cpus'] for n in cld['nodes']])
     allowed_cpus = sum([n['cpus_allowed'] for n in cld['nodes']])
     mmax = sum([n['max_mem'] for n in cld['nodes']])
     cluster_health = all([n['healthy'] for n in cld['nodes']])
     ip = "127.0.0.1" if __H2OCONN__._ip == "localhost" else __H2OCONN__._ip
     cluster_info = [
         [
             "H2O cluster uptime: ",
             get_human_readable_time(cld["cloud_uptime_millis"])
         ],
         ["H2O cluster version: ", cld["version"]],
         ["H2O cluster name: ", cld["cloud_name"]],
         ["H2O cluster total nodes: ", cld["cloud_size"]],
         ["H2O cluster total memory: ",
          get_human_readable_size(mmax)],
         ["H2O cluster total cores: ",
          str(ncpus)],
         ["H2O cluster allowed cores: ",
          str(allowed_cpus)],
         ["H2O cluster healthy: ",
          str(cluster_health)],
         ["H2O Connection ip: ", ip],
         ["H2O Connection port: ", __H2OCONN__._port],
     ]
     __H2OCONN__._cld = H2OConnection.get_json(
         url_suffix="Cloud")  # update the cached version of cld
     h2o.H2ODisplay(cluster_info)
예제 #2
0
    def show(self, header=True):
        #if h2o.can_use_pandas():
        #  import pandas
        #  pandas.options.display.max_rows = 20
        #  print pandas.DataFrame(self.cell_values,columns=self.col_header)
        #  return
        print
        if header:
            print self.table_header + ":",
            if self.table_description: print self.table_description
        print
        table = copy.deepcopy(self.cell_values)
        nr = 0
        if _is_list_of_lists(table):
            nr = len(
                table
            )  # only set if we truly have multiple rows... not just one long row :)
        if nr > 20:  # create a truncated view of the table, first/last 5 rows
            trunc_table = []
            trunc_table += [v for v in table[:5]]
            trunc_table.append(["---"] * len(table[0]))
            trunc_table += [v for v in table[(nr - 5):]]
            table = trunc_table

        h2o.H2ODisplay(table,
                       self.col_header,
                       numalign="left",
                       stralign="left")
예제 #3
0
  def show(self, header=True):
    print
    if header: print self.table_header + ":"
    print
    table = copy.deepcopy(self.cell_values)
    nr=0
    if _is_list_of_lists(table): nr = len(table)  # only set if we truly have multiple rows... not just one long row :)
    if nr > 20:    # create a truncated view of the table, first/last 5 rows
      trunc_table =[]
      trunc_table += [ v for v in table[:5]]
      trunc_table.append(["---"]*len(table[0]))
      trunc_table += [v for v in table[(nr-5):]]
      table = trunc_table

    h2o.H2ODisplay(table, self.col_header, numalign="left", stralign="left")
예제 #4
0
    def show(self, noprint=False):
        """
    Evaluate and print.

    :return: None
    """
        self.eager()
        if noprint:
            if isinstance(self._data, unicode):
                j = h2o.frame(self._data)
                data = [
                    c['data'] if c['type'] != "string" else c["string_data"]
                    for c in j['frames'][0]['columns'][:]
                ]
                domains = [c['domain'] for c in j['frames'][0]['columns']]
                for i in range(len(data)):
                    if domains[i] is not None:
                        for j in range(len(data[i])):
                            if data[i][j] == "NaN": continue
                            data[i][j] = domains[i][int(data[i][j])]
                data = map(list, zip(*data))
                return data[0:min(10, len(data))]
            return self._data
        else:
            if isinstance(self._data, unicode):
                j = h2o.frame(self._data)
                data = [c['data'] for c in j['frames'][0]['columns'][:]]
            elif isinstance(self._data, (int, float, str, list)):
                print self._data
                print
                return
            else:
                data = [self._data]
            t_data = map(list, zip(*data))
            t_data = t_data[0:min(10, len(t_data))]
            for didx, d in enumerate(t_data):
                t_data[didx].insert(0, didx)
            headers = ["Row ID"]
            for i in range(len(t_data[0])):
                headers.append('')
            print "Displaying first " + str(len(t_data)) + " row(s)"
            h2o.H2ODisplay(t_data, headers)
예제 #5
0
 def summary(self, header=True):
   """
   Print a detailed summary of the explored models.
   """
   table = []
   for model in self.models:
     model_summary = model._model_json["output"]["model_summary"]
     r_values = list(model_summary.cell_values[0])
     r_values[0] = model.model_id
     table.append(r_values)
       
   # if h2o.can_use_pandas():
   #  import pandas
   #  pandas.options.display.max_rows = 20
   #  print pandas.DataFrame(table,columns=self.col_header)
   #  return
   print
   if header:
     print 'Grid Summary:'
   print    
   h2o.H2ODisplay(table, ['Model Id'] + model_summary.col_header[1:], numalign="left", stralign="left")
예제 #6
0
             y="flsa_repeat_violator",
             training_frame=train,
             validation_frame=test)

mod_elapsed = time.time() - s

# In[ ]:

# Model performance comparison
train_ll_orig = dl_orig.model_performance(train).logloss()
test_ll_orig = dl_orig.model_performance(test).logloss()
train_ll_mod = dl_mod.model_performance(train).logloss()
test_ll_mod = dl_mod.model_performance(test).logloss()

# Print results in pretty HTML table
header = ["Metric", "Original", "Reduced"]
table = [
    ["Runtime", orig_elapsed, mod_elapsed],
    ["Train LogLoss", train_ll_orig, train_ll_mod],
    ["Test LogLoss", test_ll_orig, test_ll_mod],
]
h2o.H2ODisplay(table, header)

# ### Shut down the cluster
#
# Shut down the cluster now that we are done using it.

# In[ ]:

h2o.shutdown(prompt=False)