lzhengning
/
JittorMirror
mirror of https://github.com/Jittor/Jittor
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/Jittor/jittor into searchsort

This commit is contained in:
Gword 2020-12-22 16:48:05 +08:00
parent 25510ddf32 1b6970f7dc
commit 5d3a5ecf03
14 changed files with 125 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
python/jittor/__init__.py
View File

@ -7,7 +7,7 @@
# This file is subject to the terms and conditions defined in
# file 'LICENSE.txt', which is part of this source code package.
# ***************************************************************
__version__ = '1.2.2.8'
__version__ = '1.2.2.9'
from . import lock
with lock.lock_scope():
ori_int = int
@ -336,9 +336,9 @@ def flatten(input, start_dim=0, end_dim=-1):
return input.reshape(out_shape)
Var.flatten = flatten
def detach_inplace(x):
return x.swap(x.stop_grad().clone())
Var.start_grad = Var.detach_inplace = detach_inplace
def start_grad(x):
return x._update(x)
Var.detach_inplace = Var.start_grad = start_grad
def detach(x):
return x.detach()
@ -476,6 +476,9 @@ def load(path):
model_dict = safeunpickle(path)
return model_dict
def save(params_dict, path):
safepickle(params_dict, path)
def _uniq(x):
a = set()
b = []
@ -539,6 +542,7 @@ class Module:
def callback(parents, k, v, n):
stack.append(str(k))
for k2, p in v.__dict__.items():
if k2.startswith("_"): continue
if isinstance(p, Var):
ps.append(p)
p.name(".".join(stack[1:]+[str(k2)]))

8
python/jittor/compile_extern.py
View File

@ -183,7 +183,7 @@ def install_cutt(root_folder):
filename = "cutt-master.zip"
fullname = os.path.join(root_folder, filename)
dirname = os.path.join(root_folder, filename.replace(".zip",""))
true_md5 = "a6f4f7f75310a69b131e21f1ebec768a"
true_md5 = "af5bc35eea1832a42c0e0011659b7209"
if os.path.exists(fullname):
md5 = run_cmd('md5sum '+fullname).split()[0]
@ -205,7 +205,11 @@ def install_cutt(root_folder):
zf.close()
LOG.i("installing cutt...")
run_cmd(f"make", cwd=dirname)
arch_flag = ""
if len(flags.cuda_archs):
arch_flag = f" -arch=compute_{min(flags.cuda_archs)} "
arch_flag += ''.join(map(lambda x:f' -code=sm_{x} ', flags.cuda_archs))
run_cmd(f"make NVCC_GENCODE='{arch_flag}'", cwd=dirname)
return dirname
def setup_cutt():

14
python/jittor/dataset/dataset.py
View File

@ -310,6 +310,20 @@ Example::
self.workers = workers
self.index_list_numpy = np.ndarray(dtype='int32', shape=self.real_len, buffer=self.index_list)
def reset(self):
if not hasattr(self, "workers"):
return
self._stop_all_workers()
self.terminate()
del self.index_list
del self.idmap
del self.gid
del self.gidc
del self.num_idle
del self.num_idle_c
del self.workers
del self.index_list_numpy
def __del__(self):
if mp_log_v:
print("dataset deleted")

5
python/jittor/nn.py
View File

@ -939,8 +939,9 @@ class Sigmoid(Module):
def execute(self, x) :
return x.sigmoid()
def softplus(x,beta=1,threshold=20):
return 1 / beta * jt.log(1 + (beta * x).exp())
def softplus(x,beta=1.0,threshold=20.0):
return 1 / beta * jt.log(1 + (beta * x).minimum(threshold).exp()) + \
(x - threshold/beta).maximum(0.0)
def hardtanh(x,min_val=-1,max_val=1):
return jt.clamp(x,min_v=min_val,max_v=max_val)

20
python/jittor/optim.py
View File

@ -118,6 +118,12 @@ class SGD(Optimizer):
for p in pg["params"]:
values.append(jt.zeros(p.shape, p.dtype).stop_grad())
def add_param_group(self, group):
values = group["values"] = []
for p in group["params"]:
values.append(jt.zeros(p.shape, p.dtype).stop_grad())
self.param_groups.append(group)
def step(self, loss=None):
if loss is not None:
self.pre_step(loss)
@ -162,6 +168,12 @@ class RMSprop(Optimizer):
for p in pg["params"]:
values.append(jt.zeros(p.shape, p.dtype).stop_grad())
def add_param_group(self, group):
values = group["values"] = []
for p in group["params"]:
values.append(jt.zeros(p.shape, p.dtype).stop_grad())
self.param_groups.append(group)
def step(self, loss=None):
if loss is not None:
self.pre_step(loss)
@ -198,6 +210,14 @@ class Adam(Optimizer):
values.append(jt.zeros(p.shape, p.dtype).stop_grad())
m.append(jt.zeros(p.shape, p.dtype).stop_grad())
def add_param_group(self, group):
values = group["values"] = []
m = group["m"] = []
for p in group["params"]:
values.append(jt.zeros(p.shape, p.dtype).stop_grad())
m.append(jt.zeros(p.shape, p.dtype).stop_grad())
self.param_groups.append(group)
def step(self, loss=None):
if loss is not None:
self.pre_step(loss)

7
python/jittor/pool.py
View File

@ -30,11 +30,14 @@ class Pool(Module):
if self.ceil_mode == False:
h = (H+self.padding*2-self.kernel_size)//self.stride+1
w = (W+self.padding*2-self.kernel_size)//self.stride+1
use_code_op = self.op in ['maximum', 'minimum']
# some second order avg_pool is require, so we don't use code op here
else:
h = (H+self.padding*2-self.kernel_size + self.stride - 1)//self.stride+1
w = (W+self.padding*2-self.kernel_size + self.stride - 1)//self.stride+1
use_code_op = self.op in ['maximum', 'minimum', 'mean']
if self.op in ['maximum', 'minimum', 'mean']:
if use_code_op:
if self.op == 'mean':
if self.count_include_pad:
count = f"int count = {self.kernel_size*self.kernel_size};"
@ -187,5 +190,5 @@ class AdaptiveAvgPool2d(Module):
])
return xx.reduce("mean", [4,5])
def pool(x, kernel_size, op, padding=0, stride = 1):
def pool(x, kernel_size, op, padding=0, stride=None):
return Pool(kernel_size, stride, padding, op=op)(x)

11
python/jittor/test/test_grad.py
View File

@ -162,5 +162,16 @@ class TestGrad(unittest.TestCase):
jt.clean()
assert jt.liveness_info()["lived_vars"] == 2
def test_requires_grad(self):
a = jt.array(2.0)
assert a.requires_grad == True
a.requires_grad = False
assert a.requires_grad == False
assert jt.grad(a**2, a) == 0
a.requires_grad = True
assert a.requires_grad == True
assert jt.grad(a**2, a) == 4
if __name__ == "__main__":
unittest.main()

2
python/jittor/version
View File

@ -1 +1 @@
d2eb452b81e704188346a788d8d53889f7b12007
a83c2983e7581236ad125c5f92a1407e12fed4ac

32
python/jittor_utils/auto_diff.py
View File

@ -29,12 +29,25 @@ def convert(data):
rand_hooked = False
def hook_pt_rand(*shape):
def hook_pt_rand(*shape, device=None):
import torch
if isinstance(shape, tuple) and len(shape)==1 and isinstance(shape[0], torch.Size):
shape = tuple(shape[0])
np.random.seed(0)
return torch.from_numpy(np.random.rand(*tuple(shape)).astype("float32"))
res = torch.from_numpy(np.random.rand(*tuple(shape)).astype("float32"))
if device is not None:
return res.to(device)
return res
def hook_pt_randn(*shape, device=None):
import torch
if isinstance(shape, tuple) and len(shape)==1 and isinstance(shape[0], torch.Size):
shape = tuple(shape[0])
np.random.seed(0)
res = torch.from_numpy(np.random.randn(*tuple(shape)).astype("float32"))
if device is not None:
return res.to(device)
return res
def hook_pt_normal(mean, std):
import torch
@ -60,6 +73,7 @@ def hook_rand():
torch = sys.modules["torch"]
torch.rand = hook_pt_rand
torch.normal = hook_pt_normal
torch.randn = hook_pt_randn
torch.manual_seed(0)
if "jittor" in sys.modules:
jittor = sys.modules["jittor"]
@ -104,6 +118,12 @@ class Hook:
def check(self, name, pre_data, data):
global has_error
if pre_data is None and isinstance(data, np.ndarray):
if (data==0).all():
LOG.i(f"name {name} is None")
else:
LOG.e(f"name {name} is non-zero")
return
if type(pre_data) != type(data):
LOG.e(f"type not match, {pre_data.__class__.__name__}!={data.__class__.__name__}, name: {name}")
has_error += 1
@ -300,10 +320,4 @@ class Hook:
self.record(f"{opt_name}.grads[{gid}]", p.grad)
self.record(f"{opt_name}.params[{gid}]", p)
gid += 1
opt.step = step_hook
opt.step = step_hook

2
script/converter_server.sh
View File

@ -9,6 +9,6 @@ docker build --tag jittor/converter_server -f /tmp/converter_server.dockerfile .
# docker run --rm -it -m 16g --cpus=8 -p 0.0.0.0:5000:5000 jittor/converter_server bash -c "python3.7 -m pip install -U git+https://github.com/Jittor/jittor.git && python3.7 -m jittor.utils.converter_server"
while true; do
timeout --foreground 24h docker run --rm -it -m 16g --cpus=8 -p 0.0.0.0:5000:5000 jittor/converter_server bash -c "python3.7 -m pip install -U git+https://github.com/Jittor/jittor.git && python3.7 -m jittor.utils.converter_server"
timeout --foreground 24h docker run --rm -it -m 16g --cpus=8 -p 0.0.0.0:5000:5000 -v ~/https:/https jittor/converter_server bash -c "python3.7 -m pip install -U git+https://github.com/Jittor/jittor.git && FLASK_APP=/usr/local/lib/python3.7/dist-packages/jittor/utils/converter_server python3.7 -m flask run --cert=/https/fullchain.pem --key=/https/privkey.pem --host=0.0.0.0"
sleep 10
done

3
src/misc/nan_checker.cc
View File

@ -23,7 +23,7 @@ extern void check_nan_float64(float64* ptr, int64 num);
#endif
bool check_nan(Var* v) {
if (!v->dtype().is_float()) return true;
if (!v->dtype().is_float() || v->num == 0) return true;
if (v->input() && (
v->input()->name() == string("empty") ||
v->input()->name() == string("setitem")))
@ -37,6 +37,7 @@ bool check_nan(Var* v) {
check_nan_float64((float64*)v->mem_ptr, v->num);
}
ASSERT(cudaDeviceSynchronize()==0) << "detect nan or inf at" << v;
ASSERT(cudaGetLastError() == 0);
} else
#endif
{

2
src/update_queue.cc
View File

@ -142,6 +142,8 @@ void UpdateQueue::push(Var* v, Var* prev) {
void UpdateQueue::pop(Var* v) {
auto iter = map.find(v);
iter->second->owner->erase(iter->second);
if (iter->second->owner->size() == 0)
queue.erase(iter->second->owner);
map.erase(iter);
}

10
src/var_holder.cc
View File

@ -100,6 +100,16 @@ VarHolder* VarHolder::update(VarHolder* v) {
return this;
}
VarHolder* VarHolder::_update(VarHolder* v) {
auto dv = jittor::detach(v->var);
if (var->flags.get(NodeFlags::_in_update_queue))
update_queue.push(dv.ptr, var);
var->release_both_liveness();
var = dv.ptr;
dv.ptr = nullptr;
return this;
}
extern Executor exe;
void VarHolder::sync(bool device_sync) {

19
src/var_holder.h
View File

@ -56,6 +56,10 @@ struct VarHolder {
// @pyjt(update)
// @attrs(return_self)
VarHolder* update(VarHolder* v);
/* update parameter without set attribute */
// @pyjt(_update)
// @attrs(return_self)
VarHolder* _update(VarHolder* v);
// @pyjt(swap)
// @attrs(return_self)
@ -120,6 +124,21 @@ struct VarHolder {
return var->shape;
}
// @pyjt(__get__requires_grad)
inline bool get_requires_grad() {
return !var->is_stop_grad();
}
// @pyjt(__set__requires_grad)
inline void set_requires_grad(bool flag) {
if (flag == get_requires_grad()) return;
if (flag)
_update(this);
else
stop_grad();
return;
}
// @pyjt(__get__uncertain_shape)
inline NanoVector uncertain_shape() {
return var->shape;