Home » Ice-hockey » International » Champions Hockey League

Champions Hockey League stats & predictions

Today

">

The Economic Impact of Ice Hockey: Sponsorships and Revenue Streams

[0]: import copy [1]: import os [2]: import numpy as np [3]: import torch [4]: from tqdm import tqdm [5]: from . import registry [6]: from .base_model import BaseModel [7]: from ..core.config import cfg [8]: from ..core.engine.inference_context import inference_context [9]: from ..core.evaluation.evaluator import inference_and_eval [10]: from ..core.engine.trainer import do_train [11]: from ..core.utils.checkpoint import DetectronCheckpointer [12]: from ..data.build import build_detection_test_loader [13]: @registry.register_model("SDFNetwork") [14]: class SDFNetwork(BaseModel): [15]: """ [16]: Implement SDFNetwork model. [17]: Currently only support single-GPU training. [18]: """ [19]: def __init__(self, cfg): [20]: super().__init__(cfg) [21]: # Build SDFNetwork model. [22]: self.model = self.build_model(cfg) [23]: self.register_hooks() [24]: self.checkpointer = DetectronCheckpointer( [25]: # Assume you want to save checkpoints together with logs/statistics. [26]: model=self.model, [27]: optimizer=self.optimizer, [28]: scheduler=self.scheduler, [29]: save_dir=cfg.OUTPUT_DIR, [30]: ) [31]: self.load_pretrained_model(cfg) [32]: def build_model(self, cfg): [33]: model = registry.import_modules(cfg.MODEL.SDFNET.NAME)(cfg) [34]: return model [35]: def load_pretrained_model(self, cfg): [36]: if cfg.MODEL.WEIGHTS: [37]: print("load pretrained weights") [38]: self.checkpointer.load(cfg.MODEL.WEIGHTS) [39]: def forward(self, batched_inputs): # SDFNet forward pass. loss_dict = self.model(batched_inputs) losses = sum(loss_dict.values()) if not torch.isfinite(losses).all(): print("Loss is {}, stopping training".format(losses)) print(loss_dict) raise FloatingPointError() return losses # Build train data loader. data_loader = self.build_train_loader(cfg) start_iter = ( self.checkpointer.resume_or_load(cfg.MODEL.WEIGHTS).get("iteration", -1) + 1 ) with inference_context(self.model), torch.no_grad(): self.model.eval() for idx in range(start_iter, cfg.SOLVER.MAX_ITER + start_iter): data_batch = next(data_loader_iter) outputs = self.model(data_batch) loss_dict = outputs["loss"] losses_reduced = {k: v.item() for k, v in loss_dict.items()} loss_value = sum(losses_reduced.values()) if not np.isfinite(loss_value): print("Loss is {}, stopping training".format(loss_value)) print(loss_dict) sys.exit(1) self.optimizer.zero_grad() loss_value.backward() grad_norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), cfg.SOLVER.GRAD_CLIP) self.optimizer.step() storage = get_event_storage() storage.put_scalar("lr", self.scheduler.get_lr()[0], smoothing_hint=False) storage.put_scalar("max_grad_norm", grad_norm) if idx % cfg.SOLVER.SHOW_INTERVAL == 0: storage.put_scalars(total_loss=loss_value,**losses_reduced) if idx % cfg.SOLVER.CHECKPOINT_PERIOD == cfg.SOLVER.CHECKPOINT_PERIOD -1: writer.add_scalar("loss/total_loss", loss_value.item(), global_step=idx+1) # Do evaluation in every checkpoint epoch. do_eval_period = cfg.TEST.EVAL_PERIOD > 0 and (idx % cfg.TEST.EVAL_PERIOD == 0 or idx == cfg.SOLVER.MAX_ITER -1) if do_eval_period: results_path = os.path.join(cfg.OUTPUT_DIR,"inference", f"model_{idx}.pth") torch.save(self.model.state_dict(), results_path) inference_and_eval( self.model, build_detection_test_loader(cfg), results_path, os.path.join(cfg.OUTPUT_DIR,"inference",f"model_{idx}.json"), ) return model [ "SDFNet", ] [ ] def build_sdfnet(cfg): [ "sdfnet", ] def sdfnet_worker_init_fn(worker_id): <|file_sep|>#pragma once #include "sdfnet.h" #include "mesh.h" class SDFNetCuda : public SDFNet { public: // Constructor SDFNetCuda(std::string path); // Destructor ~SDFNetCuda(); // Forward pass void forward(float *xyz); // Backward pass void backward(float *grad); // Normalize point cloud void normalize_pointcloud(float *xyz); // Set parameters void set_parameters(std::vector ¶meters); private: void init_buffers(); void check_device(); int device; int threads; int blocks; float *dev_xyz; float *dev_out; float *dev_grad; float *dev_params; }; <|repo_name||>-rksid/SDFNet<|file_sep|>/cpp/CMakeLists.txt cmake_minimum_required(VERSION 3.10) project(sdfnet-cuda) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD 11) find_package(CUDA REQUIRED) find_package(CUDNN REQUIRED) find_package(CUDA_cublas REQUIRED) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) include_directories(${CUDA_INCLUDE_DIRS}) include_directories(${CUDA_cublas_INCLUDE_DIRS}) include_directories(${CUDNN_INCLUDE_DIRS}) link_directories(${CUDA_LIBRARIES}) link_directories(${CUDA_cublas_LIBRARY}) link_directories(${CUDNN_LIBRARY}) add_library(sdfnet-cuda SHARED src/sdfnet_cuda.cpp src/mesh_cuda.cu ) target_link_libraries(sdfnet-cuda cudart cublas cudnn)<|file_sep|>#pragma once #include "sdfnet.h" class SDFNet : public SDFNetBase { public: // Constructor SDFNet(std::string path); // Destructor virtual ~SDFNet(); // Forward pass virtual void forward(float *xyz) { throw std::logic_error("forward not implemented"); } // Backward pass virtual void backward(float *grad) { throw std::logic_error("backward not implemented"); } // Normalize point cloud virtual void normalize_pointcloud(float *xyz) { throw std::logic_error("normalize_pointcloud not implemented"); } protected: // Set parameters virtual void set_parameters(std::vector ¶meters) { throw std::logic_error("set_parameters not implemented"); } private: std::vector parameters_; }; <|file_sep|>#include "sdfnet_cuda.h" #include "utils.h" #include "cuda_runtime.h" #include "device_launch_parameters.h" #define THREADS_PER_BLOCK_1D (1024) __global__ void forward_kernel(float *xyz, float *out, float *params, int N, int channels, int hidden_layers, int hidden_neurons) { int tid = threadIdx.x + blockIdx.x * blockDim.x; if (tid >= N) { return; } float x = xyz[tid*channels]; float y = xyz[tid*channels +1]; float z = xyz[tid*channels +2]; float input_hidden_layer_weights[channel_size(channels+3)]; for (int i=0; i