Home » Tennis » Spain » W35 Vigo

W35 Vigo stats & predictions

Yesterday

Tomorrow

">

A Journey Through History: The Legacy of Tennis W35 Vigo Spain

The Tennis W35 Vigo Spain tournament has a rich history filled with memorable moments and legendary players. Take a journey through time as we explore significant milestones and iconic matches that have shaped the tournament's legacy. Understanding its history enhances your appreciation for each year's competition.

<|repo_name|>vitek-vrba/Neural-Network<|file_sep|>/train.py import torch import numpy as np from torch import nn from tqdm import tqdm from torch.utils.data import DataLoader from dataset import Dataset from models import * from utils import * def train(model_name: str, num_epochs: int, batch_size: int, learning_rate: float, weight_decay: float, num_workers: int, device: str): # Loading train dataset train_set = Dataset('train') # Setting up dataloader train_loader = DataLoader(dataset=train_set, batch_size=batch_size, shuffle=True, num_workers=num_workers) # Loading test dataset test_set = Dataset('test') # Setting up dataloader test_loader = DataLoader(dataset=test_set, batch_size=batch_size, shuffle=False, num_workers=num_workers) # Selecting model if model_name == 'fc': model = FCNet().to(device) model_path = f'{model_name}_model.pth' criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, mode='min', factor=0.5, patience=20) print(f'FCN model has {get_num_params(model):,.0f} parameters') model_name = 'fc' elif model_name == 'cnn': model = CNNNet().to(device) model_path = f'{model_name}_model.pth' criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, mode='min', factor=0.5, patience=20) print(f'CNN model has {get_num_params(model):,.0f} parameters') model_name = 'cnn' # Main training loop for epoch in range(num_epochs): # Forward pass outputs = model(images) loss = criterion(outputs, labels) # Backward pass optimizer.zero_grad() loss.backward() optimizer.step() # Validation # Switching model into evaluation mode model.eval() correct = total = val_loss =0 # Disabling gradient computation with torch.no_grad(): for images_, labels_ in tqdm(test_loader): images_ , labels_ = images_.to(device), labels_.to(device) outputs_ = model(images_) loss_ = criterion(outputs_, labels_) val_loss += loss_.item() * images_.size(0) _, predicted_ = torch.max(outputs_, dim=1) total += labels_.size(0) correct += (predicted_ == labels_).sum().item() val_accuarcy_ = correct / total print(f'nEpoch [{epoch+1}/{num_epochs}], ' f'Train Loss: {loss.item():.4f}, ' f'Validation Loss: {val_loss / total:.4f}, ' f'Validation Accuracy: {val_accuarcy_:.4f}') # Storing best accuracy result if val_accuarcy_ > best_acc: best_acc = val_accuarcy_ save_checkpoint(model_path=model_path, state_dict=model.state_dict(), acc=val_accuarcy_, epoch=epoch +1) # Switching model back into training mode model.train() # Scheduler step scheduler.step(val_loss / total) if __name__ == '__main__': <|repo_name|>vitek-vrba/Neural-Network<|file_sep|>/utils.py import os import torch def get_num_params(model): def save_checkpoint(model_path, state_dict, acc, epoch): def load_checkpoint(model_path, device): if __name__ == '__main__': <|repo_name|>vitek-vrba/Neural-Network<|file_sep|>/models.py import torch.nn as nn import torch.nn.functional as F class FCNet(nn.Module): class CNNNet(nn.Module): if __name__ == '__main__': <|repo_name|>vitek-vrba/Neural-Network<|file_sep|>/dataset.py import os import pickle import numpy as np from PIL import Image from torch.utils.data import Dataset class Dataset(Dataset): if __name__ == '__main__': <|file_sep|>#include "gmock/gmock.h" #include "gtest/gtest.h" #include "src/rpc/handler.hpp" #include "src/rpc/impl/handler_impl.hpp" #include "src/rpc/impl/server_impl.hpp" #include "src/rpc/message.hpp" #include "src/rpc/request.hpp" #include "src/rpc/response.hpp" #include "src/rpc/server.hpp" using ::testing::_; using ::testing::Invoke; using ::testing::Return; using ::testing::StrictMock; namespace rpc { namespace impl { struct MockHandler : public Handler { public: MockHandler() : rpc_handler_(nullptr) {} void setRpcHandler(RpcHandler* rpc_handler) { rpc_handler_ = rpc_handler; } void invoke(const std::string& method_id) override { (*rpc_handler_)(method_id); } private: RpcHandler* rpc_handler_; }; struct MockServer : public Server { public: explicit MockServer(ServerConfig config) : server_(config) {} void setRpcHandler(RpcHandler handler) { handler_ = handler; } std::shared_ptr> processRequest( const std::shared_ptr>& request_message) override { return server_.processRequest(request_message); } private: ServerImpl server_; RpcHandler handler_; }; struct MockHandlerImpl : public HandlerImpl { public: explicit MockHandlerImpl(const std::string& method_id) : method_id_(method_id) {} void invoke() override { handler_.invoke(method_id_); } private: std::string method_id_; StrictMock* handler_; }; TEST(RpcTestSuite, test_method_call_by_id) { const std::string method_id("test_method"); std::string result; const std::string payload("payload"); EXPECT_CALL(handler_, invoke(method_id)).WillOnce(Invoke([&result](const std::string& m_id) { EXPECT_EQ(method_id.c_str(), m_id.c_str()); result.append(m_id); })); handler_impl_.reset(new MockHandlerImpl(method_id)); handler_impl_->invoke(); EXPECT_EQ(method_id.c_str(), result.c_str()); } TEST(RpcTestSuite, test_server_process_request_method_call_by_id) { const std::string method_id("test_method"); const std::string payload("payload"); std::string result; EXPECT_CALL(handler_, invoke(method_id)).WillOnce(Invoke([&result](const std::string& m_id) { EXPECT_EQ(method_id.c_str(), m_id.c_str()); result.append(m_id); })); server.setRpcHandler(handler); auto request_message = std::make_shared>(RequestMessage(method_id)); request_message->setPayload(Payload(payload)); auto response_message = server.processRequest(request_message); auto response_payload = response_message->getPayload(); EXPECT_EQ(payload.c_str(), response_payload.getPayload().c_str()); EXPECT_EQ(method_id.c_str(), result.c_str()); } } // namespace impl } // namespace rpc <|file_sep|>#pragma once #include "json/json.h" namespace json { // TODO(gernest): remove this alias once JsonCpp is removed. using ValuePtr = Json::Value*; using ValueConstPtr = const Json::Value*; } <|repo_name|>gernest/baum-cpp-server<|file_sep|>/CMakeLists.txt cmake_minimum_required(VERSION 3.10) project(baum-cpp-server VERSION 0.1 LANGUAGES CXX) set(CMAKE_CXX_STANDARD_REQUIRED ON) find_package(Threads REQUIRED) add_subdirectory(src) add_subdirectory(tests) add_subdirectory(benchmark)<|file_sep|>#pragma once #include "json/json.hpp" #include "server_config.hpp" namespace jsonrpc { struct MethodConfig { MethodConfig() : name_(""), params_count_(0), required_(false), static_method_(true), hidden_(false), return_type_("") {} MethodConfig(const std::string& name_, const uint32_t params_count_, const bool required_, const bool static_method_, const bool hidden_, const std::string& return_type_) : name_(name_), params_count_(params_count_), required_(required_), static_method_(static_method_), hidden_(hidden_), return_type_(return_type_) {} std::string name_; uint32_t params_count_; bool required_; bool static_method_; bool hidden_; std::string return_type_; friend Json::Value toJson(const MethodConfig& method_config); }; Json::Value toJson(const MethodConfig& method_config); } // namespace jsonrpc <|file_sep|>#include "gmock/gmock.h" #include "gtest/gtest.h" #include "src/jsonrpc/jsonrpc_methods_config_parser.hpp" using ::testing::_; namespace jsonrpc { TEST(JsonRpcMethodsConfigParserTestSuite, test_parse_json_rpc_config_with_empty_methods_list) { Json::Value json_rpc_config; json_rpc_config["methods"] = Json::arrayValue; JsonRpcMethodsConfigParser parser(json_rpc_config); EXPECT_TRUE(parser.parse()); ASSERT_TRUE(parser.isParseError()); EXPECT_EQ("", parser.getParseError().what()); } TEST(JsonRpcMethodsConfigParserTestSuite, test_parse_json_rpc_config_with_invalid_methods_list_type) { Json::Value json_rpc_config; json_rpc_config["methods"] = Json::object