def main(argv): opts, args = getopt.getopt(argv, "m:n:rd:p:t:") dump_type = device.DUMP_ALL target = '' profile = log_pattern.PROFILE_ALL logtype = log_pattern.TYPE_ALL for op, value in opts: if op == "-d": device.inputdir = value elif op == "-m": target = value dump_type = device.DUMP_BY_MAC elif op == "-n": target = value dump_type = device.DUMP_BY_NAME elif op == "-r": device.force_parsing = True elif op == "-p": profile = value elif op == "-t": logtype = value device.get_device(dump_type, target, target_device_set) for a, b in target_device_set.items(): if debug: print("{0} - {1}".format(a, b)) parsing(profile, logtype)
def get(self): util.save_url(self.request, self.response) util.fill_app_attrs(self.app, self.request.uri) user_agent = self.request.headers['User-Agent'] view = self.view.type self.view.device = device.get_device(user_agent, view) self.response.out.write(util.render_template(self.app, self.view))
def compile(source, nvcc='nvcc', options=[], keep=False, no_extern_c=False, arch=None, code=None, cache_dir=None, include_dirs=[]): if not no_extern_c: source = 'extern "C" {\n%s\n}\n' % source options = options[:] if arch is None: try: import device arch = "sm_%d%d" % device.get_device().compute_capability() except RuntimeError: pass if cache_dir is None: cache_dir = os.path.join(tempfile.gettempdir(), "svxx-cuda-compiler-cache-v1-%s" % _get_per_user_string()) from os import mkdir try: mkdir(cache_dir) except OSError, e: from errno import EEXIST if e.errno != EEXIST: raise
def fill_view_attrs(self, post_id): user_agent = self.request.headers['User-Agent'] view = self.view.type self.view.device = device.get_device(user_agent, view) client = BloggerPostClient() settings = util.get_settings() entry = client.get_one_post(settings.get('blog_id'), post_id) if entry: self.view.title = entry.title.text self.view.permalink = entry.get_html_link().href labels = [] for label in entry.category: labels.append(label.term) labels.sort() self.view.labels = labels util.save_labels(labels, self.request, self.response) self.view.published = util.get_datetime_from_iso8601(entry.published.text[:19]) if entry.updated: self.view.isUpdated = True self.view.updated = util.get_datetime_from_iso8601(entry.updated.text[:19]) self.view.content = util.replace_permalinks(entry.content.text) else: logging.error("Fail to get Atom feed for the post, #%d" % post_id)
def main(): args = parse_args() dev = device.get_device(args.serial) if not check_env(dev): print "You must have root permission" sys.exit() kill_app(dev, get_be_killed_apps(dev, args.k))
def _check_arch(self, arch): if arch is None: return try: import device capability = device.get_device().compute_capability() if tuple(map(int, tuple(arch.split("_")[1]))) > capability: from warnings import warn warn("trying to compile for a compute capability " "higher than selected GPU") except: pass
def fill_view_attrs(self): user_agent = self.request.headers['User-Agent'] view = self.view.type self.view.device = device.get_device(user_agent, view) self.view.content.blog_id = '' user = users.get_current_user() if user: user_settings = model.get_user_settings(user.user_id()) if user_settings.blog_id: self.view.content.blog_id = user_settings.blog_id if user_settings.mod_time: self.view.mod_time = user_settings.mod_time.strftime("%Y-%m-%d %H:%M:%S") else: logging.error("This feature cannot perform without user login.")
def get(self): util.save_url(self.request, self.response) util.fill_app_attrs(self.app, self.request.uri) user_agent = self.request.headers['User-Agent'] view = self.view.type self.view.device = device.get_device(user_agent, view) status_code = 400 self.response.set_status(status_code) request_pattern = re.compile('https?://[^/]+(/.*)') params = request_pattern.match(self.request.uri).group(1) self.view.status_code = status_code self.view.message = webapp.Response.http_status_message(status_code) self.view.content = params self.response.out.write(util.render_template(self.app, self.view))
def main(unused_argv): """ """ config = get_config() logger = get_logger() device = get_device() input_images = tf.placeholder( tf.float32, shape=[None, None, None, 3], name="input_images" ) logger.debug("input_images: {}".format(input_images)) for i, device_id in enumerate(device.device_list): device_name = device.make_device_name(device_id) logger.debug("device_name: {}".format(device_name)) init_op = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init_op) coord = tf.train.Coordinator() enqueue_threads = tf.train.start_queue_runners(sess=sess, coord=coord) for step in range(FLAGS.max_steps): logger.debug("step: {:06d}".format(step)) if step % FLAGS.save_checkpoint_steps == 0: pass if step % FLAGS.save_summary_steps == 0: pass coord.request_stop() coord.join(enqueue_threads)
def schedule(recordings): # get current time in UTC ctime = int(time.time()) all_recordings = recordings # create a new list of recordings based on the status recordings = [ r for r in recordings if r.status in \ (CONFLICT, SCHEDULED, RECORDING) ] # new dict for schedule information. Each entry is r.status, # r.device, r.respect_start_padding, r.respect_stop_padding schedule = {} # sort by start time recordings.sort(lambda l, o: cmp(l.start,o.start)) for r in recordings[:]: # check recordings we missed (stop passed or start over 10 # minutes ago), remember that in status and remove this # recording from the list. if r.stop < ctime or (r.start + 600 < ctime and r.status != RECORDING): schedule[r.id] = [ MISSED, None, True, True ] recordings.remove(r) elif r.status == RECORDING: # mark current running recordings schedule[r.id] = [ r.status, r.device, r.respect_start_padding, \ r.respect_stop_padding ] else: device = get_device(r.channel) if device: # set to the best device for each recording schedule[r.id] = [ SCHEDULED, device, True, True ] else: # no device found, remove from the list schedule[r.id] = [ CONFLICT, None, True, True ] recordings.remove(r) # recordings is a list fo current running or future recordings # detect possible conflicts (delayed to avoid blocking the main loop) schedule = yield conflict.resolve(recordings, schedule) for r in all_recordings: if r.id in schedule: r.status, r.device, r.respect_start_padding, \ r.respect_stop_padding = schedule[r.id]
def schedule(recordings): # get current time in UTC ctime = int(time.time()) all_recordings = recordings # create a new list of recordings based on the status recordings = [ r for r in recordings if r.status in \ (CONFLICT, SCHEDULED, RECORDING) ] # new dict for schedule information. Each entry is r.status, # r.device, r.respect_start_padding, r.respect_stop_padding schedule = {} # sort by start time recordings.sort(lambda l, o: cmp(l.start, o.start)) for r in recordings[:]: # check recordings we missed (stop passed or start over 10 # minutes ago), remember that in status and remove this # recording from the list. if r.stop < ctime or (r.start + 600 < ctime and r.status != RECORDING): schedule[r.id] = [MISSED, None, True, True] recordings.remove(r) elif r.status == RECORDING: # mark current running recordings schedule[r.id] = [ r.status, r.device, r.respect_start_padding, \ r.respect_stop_padding ] else: device = get_device(r.channel) if device: # set to the best device for each recording schedule[r.id] = [SCHEDULED, device, True, True] else: # no device found, remove from the list schedule[r.id] = [CONFLICT, None, True, True] recordings.remove(r) # recordings is a list fo current running or future recordings # detect possible conflicts (delayed to avoid blocking the main loop) schedule = yield conflict.resolve(recordings, schedule) for r in all_recordings: if r.id in schedule: r.status, r.device, r.respect_start_padding, \ r.respect_stop_padding = schedule[r.id]
""" import torch # from torchvision.models import vgg19 # vgg = vgg19(pretrained=True) # features_conv = vgg.features[:36] # vgg.features ############ DATA & TRANSFORMS from data import get_data from device import get_device device = get_device(force_cpu=False) train_loader, test_loader = get_data(device, batch_size=64, data='cifar10') ##################### MODEL from model import NetCifar2 from torchsummary import summary model = NetCifar2().to(device) summary(model, input_size=(3, 32, 32)) ##################### RUN MODEL from run import run_model epochs = 20
def set_device(self): user_agent = self.request.headers['User-Agent'] view = self.view.type self.view.device = device.get_device(user_agent, view)
def setUp(self): self.device = get_device()
... [d d d ... c c c] [d d d ... c c c] Embed: Use pretrained value -> embed models. 1. d -> one_hot d -> [0 ... 0 1 0 0 ... 0] 2. one_hot -> vec [0 ... 0 1 0 0 ... 0] -> [v1, v2, v3, ... vn] Training. Generator: -> [vec, vec, vec ... c c c] ''' device = get_device() torch.cuda.set_device(0) device = torch.device("cuda") data_cat, data_cont, max_length = load_data() padded_data_cat: torch.Tensor = \ torch.nn.utils.rnn.pad_sequence(data_cat, batch_first=True).split(split_size=PADDING, dim=1)[0] padded_data_cont: torch.Tensor = \ torch.nn.utils.rnn.pad_sequence(data_cont, batch_first=True).split(split_size=PADDING, dim=1)[0] data_train = DataLoader(TensorDataset(padded_data_cat, padded_data_cont), batch_size=BATCH_SIZE, shuffle=True)