add cpu random Generator (#26013)
yaoxuefeng
5 years ago
committed by
GitHub
parent
69742bd9a4
commit
23261ff44b
@ -0,0 +1,78 @@
|
||||
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License. */
|
||||
|
||||
#include <deque>
|
||||
#include <memory>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
#include <utility>
|
||||
|
||||
#include "paddle/fluid/framework/generator.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
|
||||
std::shared_ptr<Generator> Generator::gen_instance_ = NULL;
|
||||
|
||||
GeneratorState* Generator::GetState() {
|
||||
std::lock_guard<std::mutex> lock(this->mutex);
|
||||
return this->state_.get();
|
||||
}
|
||||
|
||||
void Generator::SetState(GeneratorState* state_in) {
|
||||
std::lock_guard<std::mutex> lock(this->mutex);
|
||||
*this->state_ = *state_in;
|
||||
}
|
||||
|
||||
uint64_t Generator::GetCurrentSeed() {
|
||||
std::lock_guard<std::mutex> lock(this->mutex);
|
||||
return this->state_->current_seed;
|
||||
}
|
||||
|
||||
uint64_t Generator::Seed() {
|
||||
std::lock_guard<std::mutex> lock(this->mutex);
|
||||
uint64_t seed;
|
||||
std::random_device de;
|
||||
seed = ((((uint64_t)de()) << 32) + de()) & 0x1FFFFFFFFFFFFF;
|
||||
this->state_->current_seed = seed;
|
||||
std::seed_seq seq({seed});
|
||||
this->state_->cpu_engine.seed(seq);
|
||||
|
||||
return this->state_->current_seed;
|
||||
}
|
||||
|
||||
void Generator::SetCurrentSeed(uint64_t seed) {
|
||||
std::lock_guard<std::mutex> lock(this->mutex);
|
||||
this->state_->current_seed = uint64_t(seed);
|
||||
std::seed_seq seq({seed});
|
||||
this->state_->cpu_engine.seed(seq);
|
||||
}
|
||||
|
||||
std::mt19937_64& Generator::GetCPUEngine() {
|
||||
std::lock_guard<std::mutex> lock(this->mutex);
|
||||
return this->state_->cpu_engine;
|
||||
}
|
||||
|
||||
void Generator::SetCPUEngine(std::mt19937_64 engine) {
|
||||
std::lock_guard<std::mutex> lock(this->mutex);
|
||||
this->state_->cpu_engine = std::mt19937_64(engine);
|
||||
}
|
||||
|
||||
uint64_t Generator::Random64() {
|
||||
std::lock_guard<std::mutex> lock(this->mutex);
|
||||
return this->state_->cpu_engine();
|
||||
}
|
||||
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,96 @@
|
||||
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <atomic>
|
||||
#include <deque>
|
||||
#include <iostream> // temp for debug
|
||||
#include <memory>
|
||||
#include <mutex> // NOLINT
|
||||
#include <random>
|
||||
#include <typeinfo>
|
||||
#include <utility>
|
||||
|
||||
namespace paddle {
|
||||
namespace framework {
|
||||
|
||||
struct GeneratorState {
|
||||
int64_t device = -1;
|
||||
uint64_t current_seed = 34342423252;
|
||||
std::mt19937_64 cpu_engine;
|
||||
};
|
||||
|
||||
struct Generator {
|
||||
Generator() {
|
||||
GeneratorState default_gen_state_cpu;
|
||||
default_gen_state_cpu.device = -1;
|
||||
default_gen_state_cpu.current_seed = 34342423252;
|
||||
std::seed_seq seq({34342423252});
|
||||
default_gen_state_cpu.cpu_engine = std::mt19937_64(seq);
|
||||
this->state_ = std::make_shared<GeneratorState>(default_gen_state_cpu);
|
||||
}
|
||||
explicit Generator(GeneratorState state_in)
|
||||
: state_{std::make_shared<GeneratorState>(state_in)} {}
|
||||
Generator(const Generator& other)
|
||||
: Generator(other, std::lock_guard<std::mutex>(other.mutex)) {}
|
||||
|
||||
// get random state
|
||||
GeneratorState* GetState();
|
||||
// set random state
|
||||
void SetState(GeneratorState* state_in);
|
||||
// get current seed
|
||||
uint64_t GetCurrentSeed();
|
||||
// random a seed and get
|
||||
uint64_t Seed();
|
||||
|
||||
// set seed
|
||||
void SetCurrentSeed(uint64_t seed);
|
||||
// get cpu engine
|
||||
std::mt19937_64& GetCPUEngine();
|
||||
// set cpu engine
|
||||
void SetCPUEngine(std::mt19937_64 engine);
|
||||
|
||||
uint64_t Random64();
|
||||
|
||||
bool is_init_py = false;
|
||||
|
||||
// CPU Generator singleton
|
||||
static std::shared_ptr<Generator> GetInstance() {
|
||||
if (NULL == gen_instance_) {
|
||||
gen_instance_.reset(new paddle::framework::Generator());
|
||||
}
|
||||
return gen_instance_;
|
||||
}
|
||||
|
||||
static std::shared_ptr<Generator> GetInstanceX() {
|
||||
if (NULL == gen_instance_) {
|
||||
gen_instance_.reset(new paddle::framework::Generator());
|
||||
}
|
||||
gen_instance_->is_init_py = true;
|
||||
return gen_instance_;
|
||||
}
|
||||
|
||||
private:
|
||||
static std::shared_ptr<Generator> gen_instance_;
|
||||
std::shared_ptr<GeneratorState> state_;
|
||||
mutable std::mutex mutex;
|
||||
|
||||
Generator(const Generator& other, const std::lock_guard<std::mutex>&)
|
||||
: state_(std::make_shared<GeneratorState>(*(other.state_))) {}
|
||||
};
|
||||
|
||||
} // namespace framework
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,51 @@
|
||||
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License. */
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifdef _POSIX_C_SOURCE
|
||||
#undef _POSIX_C_SOURCE
|
||||
#endif
|
||||
|
||||
#ifdef _XOPEN_SOURCE
|
||||
#undef _XOPEN_SOURCE
|
||||
#endif
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "paddle/fluid/framework/generator.h"
|
||||
#include "paddle/fluid/pybind/generator_py.h"
|
||||
|
||||
namespace py = pybind11;
|
||||
|
||||
namespace paddle {
|
||||
namespace pybind {
|
||||
void BindGenerator(py::module* m) {
|
||||
py::class_<framework::GeneratorState>(*m, "GeneratorState", "");
|
||||
py::class_<std::mt19937_64>(*m, "mt19937_64", "");
|
||||
py::class_<framework::Generator, std::shared_ptr<framework::Generator>>(
|
||||
*m, "Generator")
|
||||
.def(py::init([]() { return framework::Generator::GetInstanceX(); }),
|
||||
py::return_value_policy::reference)
|
||||
.def("get_state", &framework::Generator::GetState,
|
||||
py::return_value_policy::move)
|
||||
.def("set_state", &framework::Generator::SetState)
|
||||
.def("manual_seed", &framework::Generator::SetCurrentSeed)
|
||||
.def("seed", &framework::Generator::Seed)
|
||||
.def("initial_seed", &framework::Generator::GetCurrentSeed)
|
||||
.def("random", &framework::Generator::Random64)
|
||||
.def("get_cpu_engine", &framework::Generator::GetCPUEngine,
|
||||
py::return_value_policy::move)
|
||||
.def("set_cpu_engine", &framework::Generator::SetCPUEngine);
|
||||
} // end Generator
|
||||
} // end namespace pybind
|
||||
} // end namespace paddle
|
||||
@ -0,0 +1,28 @@
|
||||
// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "pybind11/pybind11.h"
|
||||
#include "pybind11/stl.h"
|
||||
|
||||
namespace py = pybind11;
|
||||
|
||||
namespace paddle {
|
||||
namespace pybind {
|
||||
|
||||
void BindGenerator(py::module* m);
|
||||
|
||||
} // namespace pybind
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,60 @@
|
||||
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
"""This is definition of generator class, which is for managing the state of the algorithm that produces pseudo random numbers."""
|
||||
|
||||
from . import core
|
||||
|
||||
__all__ = ['Generator']
|
||||
|
||||
default_rng_seed_val = 34342423252
|
||||
|
||||
|
||||
class Generator(object):
|
||||
"""Generator class"""
|
||||
|
||||
def __init__(self, device="CPU"):
|
||||
"""init"""
|
||||
self.device = device
|
||||
seed_in = default_rng_seed_val
|
||||
if self.device == "CPU":
|
||||
self.generator = core.Generator()
|
||||
self.generator.manual_seed(seed_in)
|
||||
else:
|
||||
raise ValueError(
|
||||
"generator class with device %s does not exist, currently only support generator with device 'CPU' "
|
||||
% device)
|
||||
|
||||
def get_state(self):
|
||||
return self.generator.get_state()
|
||||
|
||||
def set_state(self, state):
|
||||
self.generator.set_state(state)
|
||||
|
||||
def manual_seed(self, seed):
|
||||
self.generator.manual_seed(seed)
|
||||
|
||||
def seed(self):
|
||||
return self.generator.seed()
|
||||
|
||||
def initial_seed(self):
|
||||
return self.generator.initial_seed()
|
||||
|
||||
def random(self):
|
||||
return self.generator.random()
|
||||
|
||||
def get_cpu_engine(self):
|
||||
return self.generator.get_cpu_engine()
|
||||
|
||||
def set_cpu_engine(self, cpu_engine):
|
||||
self.generator.set_cpu_engine(cpu_engine)
|
||||
@ -0,0 +1,44 @@
|
||||
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
"""Test cloud role maker."""
|
||||
|
||||
from __future__ import print_function
|
||||
import os
|
||||
import unittest
|
||||
import paddle.fluid.generator as generator
|
||||
import time # temp for debug
|
||||
|
||||
|
||||
class TestGenerator(unittest.TestCase):
|
||||
"""
|
||||
Test cases for cpu generator.
|
||||
"""
|
||||
|
||||
def test_basic_generator(self):
|
||||
"""Test basic generator."""
|
||||
gen = generator.Generator()
|
||||
gen.manual_seed(123123143)
|
||||
s = gen.initial_seed()
|
||||
s = gen.seed()
|
||||
st = gen.get_state()
|
||||
gen.set_state(st)
|
||||
gen.random()
|
||||
gen.set_cpu_engine(gen.get_cpu_engine())
|
||||
|
||||
def test_basic_generator_error(self):
|
||||
self.assertRaises(ValueError, generator.Generator, device="CUDA")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@ -0,0 +1,119 @@
|
||||
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
"""Test cloud role maker."""
|
||||
|
||||
from __future__ import print_function
|
||||
import os
|
||||
import unittest
|
||||
import paddle.fluid.generator as generator
|
||||
|
||||
import time # temp for debug
|
||||
import paddle.fluid as fluid
|
||||
import numpy as np
|
||||
import paddle
|
||||
import paddle.fluid.core as core
|
||||
|
||||
|
||||
class TestGeneratorSeed(unittest.TestCase):
|
||||
"""
|
||||
Test cases for cpu generator seed.
|
||||
"""
|
||||
|
||||
def test_generator_uniform_random_dygraph(self):
|
||||
"""Test Generator seed."""
|
||||
gen = generator.Generator()
|
||||
|
||||
fluid.enable_dygraph()
|
||||
|
||||
gen.manual_seed(12312321111)
|
||||
x = fluid.layers.uniform_random([10], dtype="float32", min=0.0, max=1.0)
|
||||
st1 = gen.get_state()
|
||||
x1 = fluid.layers.uniform_random(
|
||||
[10], dtype="float32", min=0.0, max=1.0)
|
||||
gen.set_state(st1)
|
||||
x2 = fluid.layers.uniform_random(
|
||||
[10], dtype="float32", min=0.0, max=1.0)
|
||||
gen.manual_seed(12312321111)
|
||||
x3 = fluid.layers.uniform_random(
|
||||
[10], dtype="float32", min=0.0, max=1.0)
|
||||
x_np = x.numpy()
|
||||
x1_np = x1.numpy()
|
||||
x2_np = x2.numpy()
|
||||
x3_np = x3.numpy()
|
||||
|
||||
if not core.is_compiled_with_cuda():
|
||||
self.assertTrue(np.allclose(x1_np, x2_np))
|
||||
self.assertTrue(np.allclose(x_np, x3_np))
|
||||
|
||||
def test_generator_uniform_random_static(self):
|
||||
|
||||
fluid.disable_dygraph()
|
||||
|
||||
gen = generator.Generator()
|
||||
gen.manual_seed(123123143)
|
||||
|
||||
startup_program = fluid.Program()
|
||||
train_program = fluid.Program()
|
||||
with fluid.program_guard(train_program, startup_program):
|
||||
# example 1:
|
||||
# attr shape is a list which doesn't contain tensor Variable.
|
||||
result_1 = fluid.layers.uniform_random(shape=[3, 4])
|
||||
result_2 = fluid.layers.uniform_random(shape=[3, 4])
|
||||
|
||||
exe = fluid.Executor(fluid.CPUPlace())
|
||||
exe.run(startup_program)
|
||||
out1 = exe.run(train_program,
|
||||
feed={},
|
||||
fetch_list=[result_1, result_2])
|
||||
#gen.set_state(cur_state)
|
||||
gen.manual_seed(123123143)
|
||||
out2 = exe.run(train_program,
|
||||
feed={},
|
||||
fetch_list=[result_1, result_2])
|
||||
|
||||
out1_res1 = np.array(out1[0])
|
||||
out1_res2 = np.array(out1[1])
|
||||
out2_res1 = np.array(out2[0])
|
||||
out2_res2 = np.array(out2[1])
|
||||
|
||||
if not core.is_compiled_with_cuda():
|
||||
self.assertTrue(np.allclose(out1_res1, out2_res1))
|
||||
self.assertTrue(np.allclose(out1_res2, out2_res2))
|
||||
self.assertTrue(not np.allclose(out1_res2, out1_res1))
|
||||
|
||||
def test_generator_randint_dygraph(self):
|
||||
"""Test Generator seed."""
|
||||
gen = generator.Generator()
|
||||
|
||||
fluid.enable_dygraph()
|
||||
|
||||
gen.manual_seed(12312321111)
|
||||
x = paddle.randint(low=1)
|
||||
st1 = gen.get_state()
|
||||
x1 = paddle.randint(low=1)
|
||||
gen.set_state(st1)
|
||||
x2 = paddle.randint(low=1)
|
||||
gen.manual_seed(12312321111)
|
||||
x3 = paddle.randint(low=1)
|
||||
x_np = x.numpy()
|
||||
x1_np = x1.numpy()
|
||||
x2_np = x2.numpy()
|
||||
x3_np = x3.numpy()
|
||||
if not core.is_compiled_with_cuda():
|
||||
self.assertTrue(np.allclose(x1_np, x2_np))
|
||||
self.assertTrue(np.allclose(x_np, x3_np))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Loading…
Reference in new issue