def Execute(self, opt, args): if not args: self.Usage() nb = args[0] if not git.check_ref_format('heads/%s' % nb): print >>sys.stderr, "error: '%s' is not a valid name" % nb sys.exit(1) nb = args[0] err = [] success = [] all_projects = self.GetProjects(args[1:]) pm = Progress('Abandon %s' % nb, len(all_projects)) for project in all_projects: pm.update() status = project.AbandonBranch(nb) if status is not None: if status: success.append(project) else: err.append(project) pm.end() if err: for p in err: print >>sys.stderr,\ "error: %s/: cannot abandon %s" \ % (p.relpath, nb) sys.exit(1) elif not success: print >>sys.stderr, 'error: no project has branch %s' % nb sys.exit(1) else: print >>sys.stderr, 'Abandoned in %d project(s):\n %s' % ( len(success), '\n '.join(p.relpath for p in success))
def start(self): if self.finished: raise NotImplementedError( "Builder instance can be used only once.") self.rc = 0 if not len(self.sortedList): # if self.printUpToDate: cinfo(self.printInfo, "All targets are up-to-date. Nothing to do.") self.finished = True return self.workers = [Worker(self, i) for i in range(self.numWorkers)] try: for worker in self.workers: worker.start() for worker in self.workers: logger.debugf("Joining worker {}", worker.id) worker.join() # exception handling: progressFn have to be called with end marker finally: if self.progressFn: prg = Progress(self.numWorkers) prg.finish(self.rc) self.progressFn(prg)
def writeAnimation(human, linebuffer, animTrack, config): import numpy as np progress = Progress(len(human.getSkeleton().getBones())) log.message("Exporting animation %s.", animTrack.name) linebuffer.append(' <animation name="%s" length="%s">' % (animTrack.name, animTrack.getPlaytime())) linebuffer.append(' <tracks>') for bIdx, bone in enumerate(human.getSkeleton().getBones()): # Note: OgreXMLConverter will optimize out unused (not moving) animation tracks linebuffer.append(' <track bone="%s">' % bone.name) linebuffer.append(' <keyframes>') frameTime = 1.0 / float(animTrack.frameRate) for frameIdx in xrange(animTrack.nFrames): poseMat = animTrack.getAtFramePos(frameIdx)[bIdx] translation = poseMat[:3, 3] angle, axis, _ = transformations.rotation_from_matrix(poseMat) axis = np.asarray( axis * np.matrix(bone.getRestMatrix(offsetVect=config.offset)))[0] linebuffer.append(' <keyframe time="%s">' % (float(frameIdx) * frameTime)) linebuffer.append( ' <translate x="%s" y="%s" z="%s" />' % (translation[0], translation[1], translation[2])) # TODO account for scale linebuffer.append( ' <rotate angle="%s">' % angle) linebuffer.append( ' <axis x="%s" y="%s" z="%s" />' % (axis[0], axis[1], axis[2])) linebuffer.append(' </rotate>') linebuffer.append(' </keyframe>') linebuffer.append(' </keyframes>') linebuffer.append(' </track>') progress.step() linebuffer.append(' </tracks>') linebuffer.append(' </animation>')
def writePolylist(fp, mesh, config): progress = Progress(2) nFaces = len(mesh.fvert) fp.write( ' <polylist count="%d">\n' % nFaces + ' <input offset="0" semantic="VERTEX" source="#%s-Vertex"/>\n' % mesh.name) if config.useNormals: fp.write( ' <input offset="1" semantic="NORMAL" source="#%s-Normals"/>\n' % mesh.name + ' <input offset="2" semantic="TEXCOORD" source="#%s-UV"/>\n' % mesh.name + ' <vcount>') else: fp.write( ' <input offset="1" semantic="TEXCOORD" source="#%s-UV"/>\n' % mesh.name + ' <vcount>') fp.write( ''.join(["4 " for fv in mesh.fvert]) ) fp.write('\n' + ' </vcount>\n' ' <p>') progress.step() for fn,fv in enumerate(mesh.fvert): fuv = mesh.fuvs[fn] if config.useNormals: fp.write( ''.join([("%d %d %d " % (fv[n], fv[n], fuv[n])) for n in range(4)]) ) else: fp.write( ''.join([("%d %d " % (fv[n], fuv[n])) for n in range(4)]) ) fp.write( ' </p>\n' + ' </polylist>\n') progress.step()
def Execute(self, opt, args): if not args: self.Usage() nb = args[0] err = [] all = self.GetProjects(args[1:]) pm = Progress('Checkout %s' % nb, len(all)) for project in all: pm.update() if not project.CheckoutBranch(nb): err.append(project) pm.end() if err: if len(err) == len(all): print >> sys.stderr, 'error: no project has branch %s' % nb else: for p in err: print >>sys.stderr,\ "error: %s/: cannot checkout %s" \ % (p.relpath, nb) sys.exit(1)
def mapMaskSoft(dimensions=(1024, 1024), mesh=None): """ Create a texture mask for the selected human (software renderer). """ progress = Progress()(0) if mesh is None: mesh = G.app.selectedHuman.mesh W = dimensions[0] H = dimensions[1] components = 4 dstImg = mh.Image(width=W, height=H, components=components) dstImg.data[...] = np.tile([0, 0, 0, 255], (H, W)).reshape( (H, W, components)) faces = getFaces(mesh) coords = np.asarray( [0, H])[None, None, :] + mesh.texco[mesh.fuvs[faces]] * np.asarray( [W, -H])[None, None, :] shape = mesh.fvert[faces].shape shape = tuple(list(shape) + [components]) colors = np.repeat(1, np.prod(shape)).reshape(shape) log.debug("mapMask: begin render") progress(0.1, 0.55) RasterizeTriangles(dstImg, coords[:, [0, 1, 2], :], MaskShader()) progress(0.55, 0.99) RasterizeTriangles(dstImg, coords[:, [2, 3, 0], :], MaskShader()) log.debug("mapMask: end render") progress.finish() return dstImg
def _Fetch(self, projects, opt): fetched = set() pm = Progress('Fetching projects', len(projects)) if self.jobs == 1: for project in projects: pm.update() if project.Sync_NetworkHalf(quiet=opt.quiet): fetched.add(project.gitdir) else: print >>sys.stderr, 'error: Cannot fetch %s' % project.name if opt.force_broken: print >>sys.stderr, 'warn: --force-broken, continuing to sync' else: sys.exit(1) else: threads = set() lock = _threading.Lock() sem = _threading.Semaphore(self.jobs) for project in projects: sem.acquire() t = _threading.Thread(target = self._FetchHelper, args = (opt, project, lock, fetched, pm, sem)) threads.add(t) t.start() for t in threads: t.join() pm.end() return fetched
def mapImageGL(srcImg, mesh, leftTop, rightBottom): progress = Progress() (0) log.debug("mapImageGL: 1") dstImg = G.app.selectedHuman.meshData.object3d.textureTex dstW = dstImg.width dstH = dstImg.height left, top = leftTop right, bottom = rightBottom camera = getCamera(mesh) coords = mesh.r_texco texmat = G.app.modelCamera.getConvertToScreenMatrix(mesh) texmat = matrix.scale((1/(right - left), 1/(top - bottom), 1)) * matrix.translate((-left, -bottom, 0)) * texmat texmat = np.asarray(texmat) texco = mesh.r_coord alpha = np.sum(mesh.r_vnorm * camera[None,:], axis=-1) alpha = np.maximum(alpha, 0) color = (np.array([0, 0, 0, 0])[None,...] + alpha[...,None]) * 255 color = np.ascontiguousarray(color, dtype=np.uint8) texco = np.ascontiguousarray(texco, dtype=np.float32) progress(0.5, 0.99) result = mh.renderSkin(dstImg, mesh.vertsPerPrimitive, coords, index = mesh.index, texture = srcImg, UVs = texco, textureMatrix = texmat, color = color, clearColor = None) progress(1) return result
def add_locations(request, pk=None): try: in_progress = models.UploadProgress.objects.get(pk=pk) except: raise Http404 progress = Progress(in_progress) try: locations_map = progress.progress['locations'] except KeyError: locations_map = None try: location_map = progress.progress['location'] except KeyError: location_map = None if location_map: _locations = {None: location_map} elif locations_map: _locations = locations_map else: _locations = {None: {'pk': -1, 'planting_methods': -1}} unknown_names = [ name for name in _locations if _locations[name]['pk'] == -1 ] return add_model( request, progress, unknown_names=unknown_names, template='add-locations.html', Formcls=forms.AddLocation, form_fieldname='location', input_fieldname='name', map_name=progress.map_planting_methods, is_verified=progress.locations_verified, next_url='planting-methods/', model_cache=utils.create_location_model_cache(), )
def Execute(self, opt, args): if not args: self.Usage() nb = args[0] if not git.check_ref_format('heads/%s' % nb): print >> sys.stderr, "error: '%s' is not a valid name" % nb sys.exit(1) err = [] projects = [] if not opt.all: projects = args[1:] if len(projects) < 1: print >> sys.stderr, "error: at least one project must be specified" sys.exit(1) all = self.GetProjects(projects) pm = Progress('Starting %s' % nb, len(all)) for project in all: pm.update() # If the current revision is a specific SHA1 then we can't push back # to it so substitute the manifest default revision instead. if IsId(project.revisionExpr): project.revisionExpr = self.manifest.default.revisionExpr if not project.StartBranch(nb): err.append(project) pm.end() if err: for p in err: print >>sys.stderr,\ "error: %s/: cannot start %s" \ % (p.relpath, nb) sys.exit(1)
def resetFacialCodes(self, erase_all='True'): progress_reset_button = Progress(len(self.sliders)) was_subdivided = False if self.facs_human.isSubdivided(): was_subdivided = True self.facs_human.setSubdivided(False) for aSlider in self.sliders.keys(): #if self.slidersValues[aSlider] >= 0: self.sliders[aSlider].resetValue() self.sliders[aSlider].update() self.slidersValues[aSlider] = 0 self.labelSlider[aSlider].setTextFormat('Intensity: 0%%') gui3d.app.statusPersist('Reseting : ' + aSlider) progress_reset_button.step() if erase_all: self.au_timeline_values = {} self.au_facs_loaded_file_values = {} self.txt_animatiom_file_loaded.setText('No animation file loaded') self.animation_test.onChange(0) self.animation_test.update() self.animation_test.setValue(0) self.general_intensity.onChange(100) self.general_intensity.update() self.general_intensity.setValue(100) self.au_coding.setText('Neutral') self.txt_file_loaded.setText('- New facial code -') self.facs_human.applyAllTargets() # self.refreshAuSmoothSetting() if was_subdivided == True: self.facs_human.setSubdivided(True) gui3d.app.statusPersist( 'Reset is done, now in neutral facial expression setting')
def writeShapeKey(fp, name, shape, mesh, config): if len(shape.verts) == 0: log.debug("Shapekey %s has zero verts. Ignored" % name) return progress = Progress() # Verts progress(0) target = mesh.coord.copy() target[:] += config.offset target[shape.verts] += shape.data[np.s_[...]] target = rotateCoord(config.scale*target, config) nVerts = len(target) fp.write( ' <geometry id="%sMeshMorph_%s" name="%s">\n' % (mesh.name, name, name) + ' <mesh>\n' + ' <source id="%sMeshMorph_%s-positions">\n' % (mesh.name, name) + ' <float_array id="%sMeshMorph_%s-positions-array" count="%d">\n' % (mesh.name, name, 3*nVerts) + ' ') fp.write( ''.join([("%.4f %.4f %.4f " % tuple(co)) for co in target]) ) fp.write('\n' + ' </float_array>\n' + ' <technique_common>\n' + ' <accessor source="#%sMeshMorph_%s-positions-array" count="%d" stride="3">\n' % (mesh.name, name, nVerts) + ' <param name="X" type="float"/>\n' + ' <param name="Y" type="float"/>\n' + ' <param name="Z" type="float"/>\n' + ' </accessor>\n' + ' </technique_common>\n' + ' </source>\n') progress(0.3) # Polylist nFaces = len(mesh.fvert) fp.write( ' <vertices id="%sMeshMorph_%s-vertices">\n' % (mesh.name, name) + ' <input semantic="POSITION" source="#%sMeshMorph_%s-positions"/>\n' % (mesh.name, name) + ' </vertices>\n' + ' <polylist count="%d">\n' % nFaces + ' <input semantic="VERTEX" source="#%sMeshMorph_%s-vertices" offset="0"/>\n' % (mesh.name, name) + #' <input semantic="NORMAL" source="#%sMeshMorph_%s-normals" offset="1"/>\n' % (mesh.name, name) + ' <vcount>') fp.write( ''.join(["4 " for fv in mesh.fvert]) ) fp.write('\n' + ' </vcount>\n' + ' <p>') fp.write( ''.join([("%d %d %d %d " % tuple(fv)) for fv in mesh.fvert]) ) fp.write('\n' + ' </p>\n' + ' </polylist>\n' + ' </mesh>\n' + ' </geometry>\n') progress(1)
if __name__ == '__main__': import sys sys.path.insert(0, 'C:\\Users\\James Jiang\\Documents\\Project Euler') from progress import Progress answers_list = ['dummy'] with open('C:\\Users\\James Jiang\\Documents\\Project Euler\\answers.txt' ) as answers: for line in answers: answers_list.append(int(line)) progress_ = Progress("Problem 001: Multiples of 3 and 5", 0, answers_list[1]) for x in range(1000): if (x % 3 == 0) or (x % 5 == 0): progress_.count += x progress_.progress() if __name__ == '__main__': input()
if __name__ == '__main__': import sys sys.path.insert(0, 'C:\\Users\\James Jiang\\Documents\\Project Euler') from progress import Progress answers_list = ['dummy'] with open('C:\\Users\\James Jiang\\Documents\\Project Euler\\answers.txt' ) as answers: for line in answers: answers_list.append(int(line)) progress_ = Progress("Problem 029: Distinct powers", 0, answers_list[29]) result = [] for a in range(2, 101): progress_.count = len(list(set(result))) progress_.progress() for b in range(2, 101): result.append(a**b) progress_.count = len(list(set(result))) progress_.progress() if __name__ == '__main__': input()
def Execute(self, opt, args): if opt.jobs: self.jobs = opt.jobs if self.jobs > 1: soft_limit, _ = _rlimit_nofile() self.jobs = min(self.jobs, (soft_limit - 5) / 3) if opt.network_only and opt.detach_head: print('error: cannot combine -n and -d', file=sys.stderr) sys.exit(1) if opt.network_only and opt.local_only: print('error: cannot combine -n and -l', file=sys.stderr) sys.exit(1) if opt.manifest_name and opt.smart_sync: print('error: cannot combine -m and -s', file=sys.stderr) sys.exit(1) if opt.manifest_name and opt.smart_tag: print('error: cannot combine -m and -t', file=sys.stderr) sys.exit(1) if opt.manifest_server_username or opt.manifest_server_password: if not (opt.smart_sync or opt.smart_tag): print('error: -u and -p may only be combined with -s or -t', file=sys.stderr) sys.exit(1) if None in [ opt.manifest_server_username, opt.manifest_server_password ]: print('error: both -u and -p must be given', file=sys.stderr) sys.exit(1) cwd = os.getcwd() if cwd.startswith(gitc_utils.GITC_MANIFEST_DIR) and not opt.force_gitc: print( 'WARNING this will pull all the sources like a normal repo sync.\n' '\nIf you want to update your GITC Client View please rerun this ' 'command in \n%s%s.\nOr if you actually want to pull the sources, ' 'rerun with --force-gitc.' % (gitc_utils.GITC_FS_ROOT_DIR, cwd.split(gitc_utils.GITC_MANIFEST_DIR)[1])) sys.exit(1) self._gitc_sync = False if cwd.startswith(gitc_utils.GITC_FS_ROOT_DIR): self._gitc_sync = True self._client_name = cwd.split( gitc_utils.GITC_FS_ROOT_DIR)[1].split('/')[0] self._client_dir = os.path.join(gitc_utils.GITC_MANIFEST_DIR, self._client_name) print('Updating GITC client: %s' % self._client_name) if opt.manifest_name: self.manifest.Override(opt.manifest_name) manifest_name = opt.manifest_name smart_sync_manifest_name = "smart_sync_override.xml" smart_sync_manifest_path = os.path.join( self.manifest.manifestProject.worktree, smart_sync_manifest_name) if opt.smart_sync or opt.smart_tag: if not self.manifest.manifest_server: print( 'error: cannot smart sync: no manifest server defined in ' 'manifest', file=sys.stderr) sys.exit(1) manifest_server = self.manifest.manifest_server if not opt.quiet: print('Using manifest server %s' % manifest_server) if not '@' in manifest_server: username = None password = None if opt.manifest_server_username and opt.manifest_server_password: username = opt.manifest_server_username password = opt.manifest_server_password else: try: info = netrc.netrc() except IOError: # .netrc file does not exist or could not be opened pass else: try: parse_result = urllib.parse.urlparse( manifest_server) if parse_result.hostname: auth = info.authenticators( parse_result.hostname) if auth: username, _account, password = auth else: print( 'No credentials found for %s in .netrc' % parse_result.hostname, file=sys.stderr) except netrc.NetrcParseError as e: print('Error parsing .netrc file: %s' % e, file=sys.stderr) if (username and password): manifest_server = manifest_server.replace( '://', '://%s:%s@' % (username, password), 1) transport = PersistentTransport(manifest_server) if manifest_server.startswith('persistent-'): manifest_server = manifest_server[len('persistent-'):] try: server = xmlrpc.client.Server(manifest_server, transport=transport) if opt.smart_sync: p = self.manifest.manifestProject b = p.GetBranch(p.CurrentBranch) branch = b.merge if branch.startswith(R_HEADS): branch = branch[len(R_HEADS):] env = os.environ.copy() if 'SYNC_TARGET' in env: target = env['SYNC_TARGET'] [success, manifest_str ] = server.GetApprovedManifest(branch, target) elif 'TARGET_PRODUCT' in env and 'TARGET_BUILD_VARIANT' in env: target = '%s-%s' % (env['TARGET_PRODUCT'], env['TARGET_BUILD_VARIANT']) [success, manifest_str ] = server.GetApprovedManifest(branch, target) else: [success, manifest_str] = server.GetApprovedManifest(branch) else: assert (opt.smart_tag) [success, manifest_str] = server.GetManifest(opt.smart_tag) if success: manifest_name = smart_sync_manifest_name try: f = open(smart_sync_manifest_path, 'w') try: f.write(manifest_str) finally: f.close() except IOError as e: print('error: cannot write manifest to %s:\n%s' % (smart_sync_manifest_path, e), file=sys.stderr) sys.exit(1) self._ReloadManifest(manifest_name) else: print('error: manifest server RPC call failed: %s' % manifest_str, file=sys.stderr) sys.exit(1) except (socket.error, IOError, xmlrpc.client.Fault) as e: print('error: cannot connect to manifest server %s:\n%s' % (self.manifest.manifest_server, e), file=sys.stderr) sys.exit(1) except xmlrpc.client.ProtocolError as e: print('error: cannot connect to manifest server %s:\n%d %s' % (self.manifest.manifest_server, e.errcode, e.errmsg), file=sys.stderr) sys.exit(1) else: # Not smart sync or smart tag mode if os.path.isfile(smart_sync_manifest_path): try: os.remove(smart_sync_manifest_path) except OSError as e: print( 'error: failed to remove existing smart sync override manifest: %s' % e, file=sys.stderr) rp = self.manifest.repoProject rp.PreSync() mp = self.manifest.manifestProject mp.PreSync() if opt.repo_upgraded: _PostRepoUpgrade(self.manifest, quiet=opt.quiet) if self._gitc_sync: gitc_utils.generate_gitc_manifest(self._client_dir, self.manifest) print('GITC client successfully synced.') return if not opt.local_only: mp.Sync_NetworkHalf(quiet=opt.quiet, current_branch_only=opt.current_branch_only, no_tags=opt.no_tags, optimized_fetch=opt.optimized_fetch) if mp.HasChanges: syncbuf = SyncBuffer(mp.config) mp.Sync_LocalHalf(syncbuf) if not syncbuf.Finish(): sys.exit(1) self._ReloadManifest(manifest_name) if opt.jobs is None: self.jobs = self.manifest.default.sync_j all_projects = self.GetProjects(args, missing_ok=True, submodules_ok=opt.fetch_submodules) self._fetch_times = _FetchTimes(self.manifest) if not opt.local_only: to_fetch = [] now = time.time() if _ONE_DAY_S <= (now - rp.LastFetch): to_fetch.append(rp) to_fetch.extend(all_projects) to_fetch.sort(key=self._fetch_times.Get, reverse=True) fetched = self._Fetch(to_fetch, opt) _PostRepoFetch(rp, opt.no_repo_verify) if opt.network_only: # bail out now; the rest touches the working tree return # Iteratively fetch missing and/or nested unregistered submodules previously_missing_set = set() while True: self._ReloadManifest(manifest_name) all_projects = self.GetProjects( args, missing_ok=True, submodules_ok=opt.fetch_submodules) missing = [] for project in all_projects: if project.gitdir not in fetched: missing.append(project) if not missing: break # Stop us from non-stopped fetching actually-missing repos: If set of # missing repos has not been changed from last fetch, we break. missing_set = set(p.name for p in missing) if previously_missing_set == missing_set: break previously_missing_set = missing_set fetched.update(self._Fetch(missing, opt)) if self.manifest.IsMirror or self.manifest.IsArchive: # bail out now, we have no working tree return if self.UpdateProjectList(): sys.exit(1) syncbuf = SyncBuffer(mp.config, detach_head=opt.detach_head) pm = Progress('Syncing work tree', len(all_projects)) for project in all_projects: pm.update() if project.worktree: project.Sync_LocalHalf(syncbuf, force_sync=opt.force_sync) pm.end() print(file=sys.stderr) if not syncbuf.Finish(): sys.exit(1) # If there's a notice that's supposed to print at the end of the sync, print # it now... if self.manifest.notice: print(self.manifest.notice)
def Execute(self, opt, args): nb = args[0] err = [] projects = [] if not opt.all: projects = args[1:] if len(projects) < 1: projects = ['.'] # start it in the local project by default all_projects = self.GetProjects(projects, missing_ok=bool(self.gitc_manifest)) # This must happen after we find all_projects, since GetProjects may need # the local directory, which will disappear once we save the GITC manifest. if self.gitc_manifest: gitc_projects = self.GetProjects(projects, manifest=self.gitc_manifest, missing_ok=True) for project in gitc_projects: if project.old_revision: project.already_synced = True else: project.already_synced = False project.old_revision = project.revisionExpr project.revisionExpr = None # Save the GITC manifest. gitc_utils.save_manifest(self.gitc_manifest) # Make sure we have a valid CWD if not os.path.exists(os.getcwd()): os.chdir(self.manifest.topdir) pm = Progress('Syncing %s' % nb, len(all_projects), quiet=opt.quiet) for project in all_projects: gitc_project = self.gitc_manifest.paths[project.relpath] # Sync projects that have not been opened. if not gitc_project.already_synced: proj_localdir = os.path.join( self.gitc_manifest.gitc_client_dir, project.relpath) project.worktree = proj_localdir if not os.path.exists(proj_localdir): os.makedirs(proj_localdir) project.Sync_NetworkHalf() sync_buf = SyncBuffer(self.manifest.manifestProject.config) project.Sync_LocalHalf(sync_buf) project.revisionId = gitc_project.old_revision pm.update() pm.end() def _ProcessResults(_pool, pm, results): for (result, project) in results: if not result: err.append(project) pm.update() self.ExecuteInParallel(opt.jobs, functools.partial(self._ExecuteOne, opt.revision, nb), all_projects, callback=_ProcessResults, output=Progress('Starting %s' % (nb, ), len(all_projects), quiet=opt.quiet)) if err: for p in err: print("error: %s/: cannot start %s" % (p.relpath, nb), file=sys.stderr) sys.exit(1)
def main(): # load MNIST images images, labels = dataset.load_train_images() # config discriminator_config = gan.config_discriminator generator_config = gan.config_generator # settings max_epoch = 1000 num_updates_per_epoch = 500 plot_interval = 5 batchsize_true = 100 batchsize_fake = batchsize_true # seed np.random.seed(args.seed) if args.gpu_device != -1: cuda.cupy.random.seed(args.seed) # training progress = Progress() for epoch in xrange(1, max_epoch + 1): progress.start_epoch(epoch, max_epoch) sum_loss_critic = 0 sum_loss_generator = 0 for t in xrange(num_updates_per_epoch): for k in xrange(discriminator_config.num_critic): # clamp parameters to a cube gan.clip_discriminator_weights() # gan.decay_discriminator_weights() # sample true data from data distribution images_true = dataset.sample_data(images, batchsize_true, binarize=False) # sample fake data from generator images_fake = gan.generate_x(batchsize_fake) images_fake.unchain_backward() fw_true, activations_true = gan.discriminate(images_true) fw_fake, _ = gan.discriminate(images_fake) loss_critic = -F.sum(fw_true - fw_fake) / batchsize_true sum_loss_critic += float(loss_critic.data) / discriminator_config.num_critic # update discriminator gan.backprop_discriminator(loss_critic) # generator loss images_fake = gan.generate_x(batchsize_fake) fw_fake, activations_fake = gan.discriminate(images_fake) loss_generator = -F.sum(fw_fake) / batchsize_fake # feature matching if discriminator_config.use_feature_matching: features_true = activations_true[-1] features_true.unchain_backward() if batchsize_true != batchsize_fake: images_fake = gan.generate_x(batchsize_true) _, activations_fake = gan.discriminate(images_fake, apply_softmax=False) features_fake = activations_fake[-1] loss_generator += F.mean_squared_error(features_true, features_fake) # update generator gan.backprop_generator(loss_generator) sum_loss_generator += float(loss_generator.data) if t % 10 == 0: progress.show(t, num_updates_per_epoch, {}) gan.save(args.model_dir) progress.show(num_updates_per_epoch, num_updates_per_epoch, { "wasserstein": -sum_loss_critic / num_updates_per_epoch, "loss_g": sum_loss_generator / num_updates_per_epoch, }) if epoch % plot_interval == 0 or epoch == 1: plot(filename="epoch_{}_time_{}min".format(epoch, progress.get_total_time()))
def Execute(self, opt, args): nb = args[0] err = [] projects = [] if not opt.all: projects = args[1:] if len(projects) < 1: projects = [ '.', ] # start it in the local project by default all_projects = self.GetProjects(projects, missing_ok=bool(self.gitc_manifest)) # This must happen after we find all_projects, since GetProjects may need # the local directory, which will disappear once we save the GITC manifest. if self.gitc_manifest: gitc_projects = self.GetProjects(projects, manifest=self.gitc_manifest, missing_ok=True) for project in gitc_projects: if project.old_revision: project.already_synced = True else: project.already_synced = False project.old_revision = project.revisionExpr project.revisionExpr = None # Save the GITC manifest. gitc_utils.save_manifest(self.gitc_manifest) # Make sure we have a valid CWD if not os.path.exists(os.getcwd()): os.chdir(self.manifest.topdir) pm = Progress('Starting %s' % nb, len(all_projects)) for project in all_projects: pm.update() if self.gitc_manifest: gitc_project = self.gitc_manifest.paths[project.relpath] # Sync projects that have not been opened. if not gitc_project.already_synced: proj_localdir = os.path.join( self.gitc_manifest.gitc_client_dir, project.relpath) project.worktree = proj_localdir if not os.path.exists(proj_localdir): os.makedirs(proj_localdir) project.Sync_NetworkHalf() sync_buf = SyncBuffer(self.manifest.manifestProject.config) project.Sync_LocalHalf(sync_buf) project.revisionId = gitc_project.old_revision # If the current revision is immutable, such as a SHA1, a tag or # a change, then we can't push back to it. Substitute with # dest_branch, if defined; or with manifest default revision instead. branch_merge = '' if IsImmutable(project.revisionExpr): if project.dest_branch: branch_merge = project.dest_branch else: branch_merge = self.manifest.default.revisionExpr if not project.StartBranch(nb, branch_merge=branch_merge): err.append(project) pm.end() if err: for p in err: print("error: %s/: cannot start %s" % (p.relpath, nb), file=sys.stderr) sys.exit(1)
import math if __name__ == '__main__': import sys sys.path.insert(0, 'C:\\Users\\James Jiang\\Documents\\Project Euler') from progress import Progress answers_list = ['dummy'] with open('C:\\Users\\James Jiang\\Documents\\Project Euler\\answers.txt' ) as answers: for line in answers: answers_list.append(int(line)) progress_ = Progress("Problem 073: Counting fractions in a range", 0, 12001) count = 0 for n in range(2, 12001): progress_.count = n progress_.progress() for i in range(math.floor(n / 3) + 1, math.ceil(n / 2)): if math.gcd(n, i) == 1: count += 1 progress_.count = count progress_.total = answers_list[73] progress_.progress() if __name__ == '__main__': input()
def main(): # load MNIST images train_images, train_labels = dataset.load_train_images() # config config = aae.config # settings # _l -> labeled # _u -> unlabeled max_epoch = 1000 num_trains_per_epoch = 5000 batchsize = 100 alpha = 1 # seed np.random.seed(args.seed) if args.gpu_device != -1: cuda.cupy.random.seed(args.seed) # classification # 0 -> true sample # 1 -> generated sample class_true = aae.to_variable(np.zeros(batchsize, dtype=np.int32)) class_fake = aae.to_variable(np.ones(batchsize, dtype=np.int32)) # training progress = Progress() for epoch in xrange(1, max_epoch): progress.start_epoch(epoch, max_epoch) sum_loss_reconstruction = 0 sum_loss_discriminator = 0 sum_loss_generator = 0 for t in xrange(num_trains_per_epoch): # sample from data distribution images_l, label_onehot_l, label_ids_l = dataset.sample_labeled_data( train_images, train_labels, batchsize) # reconstruction phase z_l = aae.encode_x_z(images_l) reconstruction_l = aae.decode_yz_x(label_onehot_l, z_l) loss_reconstruction = F.mean_squared_error( aae.to_variable(images_l), reconstruction_l) aae.backprop_generator(loss_reconstruction) aae.backprop_decoder(loss_reconstruction) # adversarial phase images_l = dataset.sample_labeled_data(train_images, train_labels, batchsize)[0] z_fake_l = aae.encode_x_z(images_l) z_true_l = sampler.gaussian(batchsize, config.ndim_z, mean=0, var=1) dz_true = aae.discriminate_z(z_true_l, apply_softmax=False) dz_fake = aae.discriminate_z(z_fake_l, apply_softmax=False) loss_discriminator = F.softmax_cross_entropy( dz_true, class_true) + F.softmax_cross_entropy( dz_fake, class_fake) aae.backprop_discriminator(loss_discriminator) # adversarial phase images_l = dataset.sample_labeled_data(train_images, train_labels, batchsize)[0] z_fake_l = aae.encode_x_z(images_l) dz_fake = aae.discriminate_z(z_fake_l, apply_softmax=False) loss_generator = F.softmax_cross_entropy(dz_fake, class_true) aae.backprop_generator(loss_generator) sum_loss_reconstruction += float(loss_reconstruction.data) sum_loss_discriminator += float(loss_discriminator.data) sum_loss_generator += float(loss_generator.data) if t % 10 == 0: progress.show(t, num_trains_per_epoch, {}) aae.save(args.model_dir) progress.show( num_trains_per_epoch, num_trains_per_epoch, { "loss_r": sum_loss_reconstruction / num_trains_per_epoch, "loss_d": sum_loss_discriminator / num_trains_per_epoch, "loss_g": sum_loss_generator / num_trains_per_epoch, })
all_squares = [] all_pentagons = [] all_hexagons = [] all_heptagons = [] all_octagons = [] all_nums = [ all_triangles, all_squares, all_pentagons, all_hexagons, all_heptagons, all_octagons ] for i in range(1000, 10000): for j in range(6): if all_functions[j](i): all_nums[j].append(i) progress_ = Progress("Problem 061: Cyclical figurate numbers", 0, len(all_triangles)) for triangle in all_triangles: progress_.count += 1 progress_.progress() if find_cycle(all_nums[1:], triangle // 100, triangle % 100, triangle): break progress_.count = find_cycle(all_nums[1:], triangle // 100, triangle % 100, triangle) progress_.total = answers_list[61] progress_.progress() if __name__ == '__main__': input()
def writeSkinController(fp, rmesh, amt, config): progress = Progress() progress(0, 0.1) nVerts = len(rmesh.getCoord()) nBones = len(amt.bones) skinWeights = [] vertexWeights = [list() for _ in xrange(nVerts)] wn = 0 for bn, bname in enumerate(amt.bones): try: wts = rmesh.weights[bname] except KeyError: wts = [] log.debug("W %d %s %s" % (bn, bname, wts)) skinWeights += wts for (vn, _w) in wts: vertexWeights[int(vn)].append((bn, wn)) wn += 1 nSkinWeights = len(skinWeights) progress(0.1, 0.2) fp.write('\n' + ' <controller id="%s-skin">\n' % rmesh.name + ' <skin source="#%sMesh">\n' % rmesh.name + ' <bind_shape_matrix>\n' + ' 1 0 0 0\n' + ' 0 1 0 0\n' + ' 0 0 1 0\n' + ' 0 0 0 1\n' + ' </bind_shape_matrix>\n' + ' <source id="%s-skin-joints">\n' % rmesh.name + ' <IDREF_array count="%d" id="%s-skin-joints-array">\n' % (nBones, rmesh.name) + ' ') for bone in amt.bones.values(): bname = goodBoneName(bone.name) fp.write(' %s' % bname) progress(0.2, 0.4) fp.write( '\n' + ' </IDREF_array>\n' + ' <technique_common>\n' + ' <accessor count="%d" source="#%s-skin-joints-array" stride="1">\n' % (nBones, rmesh.name) + ' <param type="IDREF" name="JOINT"></param>\n' + ' </accessor>\n' + ' </technique_common>\n' + ' </source>\n' + ' <source id="%s-skin-weights">\n' % rmesh.name + ' <float_array count="%d" id="%s-skin-weights-array">\n' % (nSkinWeights, rmesh.name) + ' ') fp.write(''.join(' %s' % w[1] for w in skinWeights)) fp.write( '\n' + ' </float_array>\n' + ' <technique_common>\n' + ' <accessor count="%d" source="#%s-skin-weights-array" stride="1">\n' % (nSkinWeights, rmesh.name) + ' <param type="float" name="WEIGHT"></param>\n' + ' </accessor>\n' + ' </technique_common>\n' + ' </source>\n' + ' <source id="%s-skin-poses">\n' % rmesh.name + ' <float_array count="%d" id="%s-skin-poses-array">' % (16 * nBones, rmesh.name)) progress(0.4, 0.6) for bone in amt.bones.values(): #mat = la.inv(bone.getRestOrTPoseMatrix(config)) mat = la.inv(bone.getRestMatrix(config)) for i in range(4): fp.write('\n ') for j in range(4): fp.write(' %.4f' % mat[i, j]) fp.write('\n') progress(0.6, 0.8) fp.write( '\n' + ' </float_array>\n' + ' <technique_common>\n' + ' <accessor count="%d" source="#%s-skin-poses-array" stride="16">\n' % (nBones, rmesh.name) + ' <param type="float4x4"></param>\n' + ' </accessor>\n' + ' </technique_common>\n' + ' </source>\n' + ' <joints>\n' + ' <input semantic="JOINT" source="#%s-skin-joints"/>\n' % rmesh.name + ' <input semantic="INV_BIND_MATRIX" source="#%s-skin-poses"/>\n' % rmesh.name + ' </joints>\n' + ' <vertex_weights count="%d">\n' % nVerts + ' <input offset="0" semantic="JOINT" source="#%s-skin-joints"/>\n' % rmesh.name + ' <input offset="1" semantic="WEIGHT" source="#%s-skin-weights"/>\n' % rmesh.name + ' <vcount>\n' + ' ') fp.write(''.join(['%d ' % len(wts) for wts in vertexWeights])) progress(0.8, 0.99) fp.write('\n' + ' </vcount>\n' ' <v>\n' + ' ') for wts in vertexWeights: fp.write(''.join([' %d %d' % pair for pair in wts])) fp.write('\n' + ' </v>\n' + ' </vertex_weights>\n' + ' </skin>\n' + ' </controller>\n') progress(1)
def writeGeometry(fp, mesh, config, shapes=None): progress = Progress() progress(0) coord = mesh.coord + config.offset coord = rotateCoord(coord, config) nVerts = len(coord) fp.write('\n' + ' <geometry id="%sMesh" name="%s">\n' % (mesh.name,mesh.name) + ' <mesh>\n' + ' <source id="%s-Position">\n' % mesh.name + ' <float_array count="%d" id="%s-Position-array">\n' % (3*nVerts,mesh.name) + ' ') fp.write( ''.join([("%.4f %.4f %.4f " % tuple(co)) for co in coord]) ) fp.write('\n' + ' </float_array>\n' + ' <technique_common>\n' + ' <accessor count="%d" source="#%s-Position-array" stride="3">\n' % (nVerts,mesh.name) + ' <param type="float" name="X"></param>\n' + ' <param type="float" name="Y"></param>\n' + ' <param type="float" name="Z"></param>\n' + ' </accessor>\n' + ' </technique_common>\n' + ' </source>\n') progress(0.2) # Normals if config.useNormals: mesh.calcNormals() vnorm = rotateCoord(mesh.vnorm, config) nNormals = len(mesh.vnorm) fp.write( ' <source id="%s-Normals">\n' % mesh.name + ' <float_array count="%d" id="%s-Normals-array">\n' % (3*nNormals,mesh.name) + ' ') fp.write( ''.join([("%.4f %.4f %.4f " % tuple(no)) for no in vnorm]) ) fp.write('\n' + ' </float_array>\n' + ' <technique_common>\n' + ' <accessor count="%d" source="#%s-Normals-array" stride="3">\n' % (nNormals,mesh.name) + ' <param type="float" name="X"></param>\n' + ' <param type="float" name="Y"></param>\n' + ' <param type="float" name="Z"></param>\n' + ' </accessor>\n' + ' </technique_common>\n' + ' </source>\n') progress(0.35) # UV coordinates nUvVerts = len(mesh.texco) fp.write( ' <source id="%s-UV">\n' % mesh.name + ' <float_array count="%d" id="%s-UV-array">\n' % (2*nUvVerts,mesh.name) + ' ') fp.write( ''.join([("%.4f %.4f " % tuple(uv)) for uv in mesh.texco]) ) fp.write('\n' + ' </float_array>\n' + ' <technique_common>\n' + ' <accessor count="%d" source="#%s-UV-array" stride="2">\n' % (nUvVerts,mesh.name) + ' <param type="float" name="S"></param>\n' + ' <param type="float" name="T"></param>\n' + ' </accessor>\n' + ' </technique_common>\n' + ' </source>\n') progress(0.5, 0.7) # Faces fp.write( ' <vertices id="%s-Vertex">\n' % mesh.name + ' <input semantic="POSITION" source="#%s-Position"/>\n' % mesh.name + ' </vertices>\n') checkFaces(mesh, nVerts, nUvVerts) progress(0.7, 0.9) writePolylist(fp, mesh, config) progress(0.9, 0.99) fp.write( ' </mesh>\n' + ' </geometry>\n') if shapes is not None: shaprog = Progress(len(shapes)) for name,shape in shapes: writeShapeKey(fp, name, shape, mesh, config) shaprog.step() progress(1)
def main(): # load MNIST images images = load_rgb_images(args.image_dir) # config config_energy_model = to_object(params_energy_model["config"]) config_generative_model = to_object(params_generative_model["config"]) # settings max_epoch = 1000 n_trains_per_epoch = 500 batchsize_positive = 128 batchsize_negative = 128 plot_interval = 5 # seed np.random.seed(args.seed) if args.gpu_device != -1: cuda.cupy.random.seed(args.seed) # init weightnorm layers if config_energy_model.use_weightnorm: print "initializing weight normalization layers of the energy model ..." x_positive = sample_from_data(images, batchsize_positive * 5) ddgm.compute_energy(x_positive) if config_generative_model.use_weightnorm: print "initializing weight normalization layers of the generative model ..." x_negative = ddgm.generate_x(batchsize_negative * 5) progress = Progress() for epoch in xrange(1, max_epoch): progress.start_epoch(epoch, max_epoch) sum_energy_positive = 0 sum_energy_negative = 0 sum_loss = 0 sum_kld = 0 for t in xrange(n_trains_per_epoch): # sample from data distribution x_positive = sample_from_data(images, batchsize_positive) # sample from generator x_negative = ddgm.generate_x(batchsize_negative) # train energy model energy_positive = ddgm.compute_energy_sum(x_positive) energy_negative = ddgm.compute_energy_sum(x_negative) loss = energy_positive - energy_negative ddgm.backprop_energy_model(loss) # train generative model # TODO: KLD must be greater than or equal to 0 x_negative = ddgm.generate_x(batchsize_negative) kld = ddgm.compute_kld_between_generator_and_energy_model( x_negative) ddgm.backprop_generative_model(kld) sum_energy_positive += float(energy_positive.data) sum_energy_negative += float(energy_negative.data) sum_loss += float(loss.data) sum_kld += float(kld.data) progress.show(t, n_trains_per_epoch, {}) progress.show( n_trains_per_epoch, n_trains_per_epoch, { "x+": int(sum_energy_positive / n_trains_per_epoch), "x-": int(sum_energy_negative / n_trains_per_epoch), "loss": sum_loss / n_trains_per_epoch, "kld": sum_kld / n_trains_per_epoch }) ddgm.save(args.model_dir) if epoch % plot_interval == 0 or epoch == 1: plot(filename="epoch_{}_time_{}min".format( epoch, progress.get_total_time()))
def _syncRemote1Finished(self): self.log.trace("Enter") progress = Progress() current = self.overrideProgressAfterDownloads prog = float(current) / float(self.overrideProgressLength) progress(prog, desc="Unzipping seed zips") if os.path.exists(self.thumbseed): self.log.debug("HAS THUMB ZIP", self.thumbseed) zip = ZipFile(self.thumbseed, 'r') if not os.path.exists(self.root): os.makedirs(self.root) zip.extractall(self.root) zip.close() if os.path.exists(self.remotedb): os.remove(self.remotedb) os.remove(self.thumbseed) current = current + 1 prog = float(current) / float(self.overrideProgressLength) progress(prog, desc="Unzipping seed zips") else: self.log.debug("Did not have thumb seed zip") if os.path.exists(self.screenseed): self.log.debug("HAS SCREEN ZIP", self.screenseed) zip = ZipFile(self.screenseed, 'r') if not os.path.exists(self.root): os.makedirs(self.root) zip.extractall(self.root) zip.close() if os.path.exists(self.remotedb): os.remove(self.remotedb) os.remove(self.screenseed) else: self.log.debug("Did not have screen seed zip") current = current + 1 prog = float(current) / float(self.overrideProgressLength) progress(prog, desc="Checking for additional files to download") self.overrideProgressLength = None self.overrideProgressAfterDownloads = None if os.path.exists(self.remotedb + ".keep"): os.rename(self.remotedb + ".keep", self.remotedb) self._loadRemoteDB() filesToDownload = [] self.log.debug("downloadScreenshots", self.downloadScreenshots) self.log.debug("downloadThumbnails", self.downloadThumbnails) for assetType in self.remoteAssets.keys(): for assetId in self.remoteAssets[assetType].keys(): remoteAsset = self.remoteAssets[assetType][assetId] tuples = remoteAsset.getDownloadTuples( ignoreExisting=True, onlyMeta=True, excludeScreenshot=not self.downloadScreenshots, excludeThumb=not self.downloadThumbnails) self.log.spam("Tuples", tuples) filesToDownload.extend(tuples) self.log.debug("filesToDownload", filesToDownload) progress(1.0) self._downloadTask = DownloadTask(self._syncParentWidget, filesToDownload, self._syncRemote2Finished, self._syncRemote2Progress)
def _Checkout(self, all_projects, opt, err_event, err_results): """Checkout projects listed in all_projects Args: all_projects: List of all projects that should be checked out. opt: Program options returned from optparse. See _Options(). err_event: We'll set this event in the case of an error (after printing out info about the error). err_results: A list of strings, paths to git repos where checkout failed. """ # Perform checkouts in multiple threads when we are using partial clone. # Without partial clone, all needed git objects are already downloaded, # in this situation it's better to use only one process because the checkout # would be mostly disk I/O; with partial clone, the objects are only # downloaded when demanded (at checkout time), which is similar to the # Sync_NetworkHalf case and parallelism would be helpful. if self.manifest.CloneFilter: syncjobs = self.jobs else: syncjobs = 1 lock = _threading.Lock() pm = Progress('Checking out projects', len(all_projects), print_newline=not (opt.quiet), always_print_percentage=opt.quiet) threads = set() sem = _threading.Semaphore(syncjobs) for project in all_projects: # Check for any errors before running any more tasks. # ...we'll let existing threads finish, though. if err_event.isSet() and opt.fail_fast: break sem.acquire() if project.worktree: kwargs = dict(opt=opt, sem=sem, project=project, lock=lock, pm=pm, err_event=err_event, err_results=err_results) if syncjobs > 1: t = _threading.Thread(target=self._CheckoutWorker, kwargs=kwargs) # Ensure that Ctrl-C will not freeze the repo process. t.daemon = True threads.add(t) t.start() else: self._CheckoutWorker(**kwargs) for t in threads: t.join() pm.end()
if __name__ == '__main__': import sys sys.path.insert(0, 'C:\\Users\\James Jiang\\Documents\\Project Euler') from functions import * from progress import Progress answers_list = ['dummy'] with open('C:\\Users\\James Jiang\\Documents\\Project Euler\\answers.txt' ) as answers: for line in answers: answers_list.append(int(line)) progress_ = Progress("Problem 050: Consecutive prime sum", 0, 1000000) prime_sum = 0 primes = [] num = 2 while True: if is_prime(num): primes.append(num) if prime_sum + num >= 1000000: break prime_sum += num progress_.count = prime_sum progress_.progress() num += 1 while not is_prime(prime_sum): prime_sum -= primes[0] del primes[0]
if __name__ == '__main__': import sys sys.path.insert(0, 'C:\\Users\\James Jiang\\Documents\\Project Euler') from functions import * from progress import Progress answers_list = ['dummy'] with open('C:\\Users\\James Jiang\\Documents\\Project Euler\\answers.txt') as answers: for line in answers: answers_list.append(int(line)) progress_ = Progress("Problem 058: Spiral primes", 0, answers_list[58]) a = 2 n = 0 while (n/(4*a - 3) >= 0.10) or (n == 0): if is_prime(4*a**2 - 10*a + 7): n += 1 if is_prime(4*a**2 - 8*a + 5): n += 1 if is_prime(4*a**2 - 6*a + 3): n += 1 #bottom-right diagonal is always an odd square a += 1 if a % 11 == 0: #arbitrary number for display purposes progress_.count = 2*a - 1 progress_.progress() progress_.count = 2*a - 1 progress_.progress()
if __name__ == '__main__': import sys sys.path.insert(0, 'C:\\Users\\James Jiang\\Documents\\Project Euler') from functions import * from progress import Progress answers_list = ['dummy'] with open('C:\\Users\\James Jiang\\Documents\\Project Euler\\answers.txt' ) as answers: for line in answers: answers_list.append(int(line)) progress_ = Progress("Problem 049: Prime permutations", 1000, int(str(answers_list[49])[:4])) done = 0 n = 1488 while True: if is_prime(n): progress_.count = n progress_.progress() for a in range(1000, 5000): if is_prime(n + a) and is_prime(n + 2 * a): digits_1 = [int(i) for i in str(n)] digits_2 = [int(i) for i in str(n + a)] digits_3 = [int(i) for i in str(n + 2 * a)] if (sorted(digits_1) == sorted(digits_2)) and (sorted(digits_1) == sorted(digits_3)): done = 1 break
raise StopIteration self.i += 1 k = self.keys[self.i] return k, self[k] def __invert__(self): _self = Symmetric_Dictionary() _self._dict = self.__dict _self.__dict = self._dict self.i = 0 return _self def __str__(self): return "\n".join([f"{k}: {v}" for k, v in self]) if __name__ == "__main__": from numpy.random import randint from progress import Progress count = 10_000 nums = range(5, count) sd = Symmetric_Dictionary() with Progress("Filling symdict", count, precision=2) as (u, _, _): for i, key in enumerate(nums): sd[key] = u(i) print("Reversing...") sd = ~sd print("Printing...") s = [f"{k}: {v}" for k, v in sd] print(s)