buildz 0.7.0__tar.gz → 0.7.2__tar.gz

{buildz-0.7.0/buildz.egg-info → buildz-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.7.0
+Version: 0.7.2
 Summary: 配置读写（基于json格式进行简化）、ioc、以及其他工具代码。a json-base file format's read and write code by python, and codes to read and product object from configure file in such format(ioc), and other tool codes
 Home-page: https://github.com/buildCodeZ/buildz
 Author: Zzz
@@ -16,6 +16,13 @@ License-File: LICENSE
 禁止将本项目代码用于ai训练
 declaration:
 Codes of this project are not allowed to be used for AI training or any other form of machine learning processes.
+
+使用此代码库发现bug或者有需求需要开发都可联系(QQ或邮箱联系，QQ就是邮箱号)
+
+邮箱1:1174534295@qq.com
+
+邮箱2:1309458652@qq.com
+
 ```
 1，在json格式基础上加了点东西，让配置文件写起来更简单，模块在buildz.xf下
 2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下

{buildz-0.7.0 → buildz-0.7.2}/README.md

@@ -3,6 +3,13 @@
 禁止将本项目代码用于ai训练
 declaration:
 Codes of this project are not allowed to be used for AI training or any other form of machine learning processes.
+
+使用此代码库发现bug或者有需求需要开发都可联系(QQ或邮箱联系，QQ就是邮箱号)
+
+邮箱1:1174534295@qq.com
+
+邮箱2:1309458652@qq.com
+
 ```
 1，在json格式基础上加了点东西，让配置文件写起来更简单，模块在buildz.xf下
 2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下

buildz-0.7.2/buildz/__init__.py

@@ -0,0 +1,25 @@
+#coding=utf-8
+
+__version__="0.7.2"
+
+# 小号多
+__author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"
+__doc__ = '''
+使用此代码库发现bug或者有需求需要开发都可联系(QQ或邮箱联系，QQ就是邮箱号)
+buildz.xf: 简化的json
+buildz.xz: 简化对dict和list的读写
+buildz.ioc, buildz.iocz: ioc注入
+buildz.netz: 网络相关，包括ssl证书生成，正反向代理，端口映射，抓包
+buildz.db: SQL脚本处理工具，基于其他SQL处理库做了使用简化
+buildz.html: html文本处理
+buildz.gpuz: 机器学习用内存做显存的模型缓存，目前只写了基于pytorch的工具，测试卷积和注意力的效果还行
+buildz.fz: 文件处理
+buildz.auto: 自动化测试
+buildz.logz: 简单的日志工具
+buildz.pyz: 简化python系统相关调用
+buildz.base: 简化python类代码编写
+buildz.pathz: 简化文件路径相关的代码编写 
+'''
+
+from .argx import fetch as args
+from .base import Base, WBase

{buildz-0.7.0 → buildz-0.7.2}/buildz/gpuz/test/analyze.py

@@ -32,16 +32,24 @@ def default_fc_opt(net, opt):
     torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
     opt.step()
 def analyze(use_cache, use_cuda, mark_train, loop, fc_gen, dataloader, loss_fn, fc_opt, win_size):
-    mds, gmodel, opts, gopt = fc_gen()
+    tmp = list(fc_gen())
+    mds = tmp.pop(0)
+    gmodel = tmp.pop(0)
+    opts = tmp.pop(0)
+    gopt = tmp.pop(0)
+    dvs_nets = None
+    if len(tmp)>0:
+        dvs_nets = tmp.pop(0)
     dv = cuda
     if not use_cuda:
         use_cache = False
     cache = None
     if use_cache:
-        cache = DictCache([cuda, cpu], mds, opts, win_size, fc_opt)
+        cache = DictCache([cuda, cpu], mds, opts, win_size, fc_opt, dvs_nets)
     if not use_cuda:
         dv = cpu
-    gmodel = gmodel.to(dv)
+    if not use_cache:
+        gmodel = gmodel.to(dv)
     s_val = "mean loss"
     if mark_train:
         if not use_cache:
@@ -59,23 +67,24 @@ def analyze(use_cache, use_cuda, mark_train, loop, fc_gen, dataloader, loss_fn,
         total_loss = 0
         curr=time.time()
         if mark_train:
-            for dt in dataloader:
+            for dt,tgt in dataloader:
                 dt=dt.to(dv)
+                tgt = tgt.to(dv)
                 if not use_cache:
                     gopt.zero_grad()
                     out = gmodel(dt)
-                    loss = loss_fn(out, dt)
+                    loss = loss_fn(out, tgt)
                     loss.backward()
                     fc_opt(gmodel, gopt)
                 else:
                     [opt.zero_grad() for opt in opts] #写gopt.zero_grad()应该也可以，只是删掉之前计算的梯度
                     out = cache.do_forward(lambda :gmodel(dt)) # 其实只是加了勾子函数，实际的计算还是模型计算
-                    loss = loss_fn(out, dt)
+                    loss = loss_fn(out, tgt)
                     cache.do_backward(lambda : loss.backward()) # 加勾子函数
                 total_loss+=loss.item()
         else:
             with torch.no_grad():
-                for dt in dataloader:
+                for dt,tgt in dataloader:
                     dt=dt.to(dv)
                     if not use_cache:
                         out = gmodel(dt)
@@ -102,6 +111,7 @@ def analyzes(mark_train, loop, fc_gen, dataloader, loss_fn = None, fc_opt = None
         fc_opt = default_fc_opt
     if 'gpu' in modes:
         modes = list(modes)+['cuda']
+    print(f"modes: {modes}")
     # 正常做法：只用显卡
     if 'cuda' in modes:
         print("No Used DictCache")

buildz-0.7.2/buildz/gpuz/test/demo.py

@@ -0,0 +1,84 @@
+
+from buildz.gpuz.torch import DictCache
+import torch
+from torch import nn,optim
+from torch.utils.data import DataLoader, Dataset
+class TestDataset(Dataset):
+    def __init__(self, num, dims):
+        self.num = num
+        self.dims = dims
+        self.datas = torch.rand(num, dims)
+        self.targets = torch.rand(num, dims)
+    def __len__(self):
+        return self.num
+    def __getitem__(self, i):
+        return self.datas[i], self.targets[i]
+dims = 12
+dataset = TestDataset(30, dims)
+dataloader = DataLoader(dataset, 10)
+class MiniModel(nn.Module):
+    def __init__(self, dims, mdims, num):
+        super().__init__()
+        nets = [nn.Linear(dims, mdims)]
+        nets += [nn.Linear(mdims,mdims) for i in range(num)]
+        nets.append(nn.Linear(mdims,dims))
+        self.nets = nn.Sequential(*nets)
+    def forward(self, inputs):
+        return self.nets(inputs)
+models = [MiniModel(dims, 32, 3) for i in range(10)]
+opts = [optim.Adam(model.parameters(), lr=0.001) for model in models]
+#可以指定哪些模型全部放cuda或者全部放cpu
+cuda_models = [models[1],models[2]]
+cpu_models = [models[-1]]
+real_model = nn.Sequential(*models)
+loss_fn = torch.nn.MSELoss()
+def opt_step(net, opt):
+    # 如果模型只是用来测试，不做训练，可以不传该函数，同时opts传入空就可以
+    # 对模型的一些其他优化，可以写可以不写，主要是调用opt.step()进行当前小模型的模型训练
+    # 另外，opt不一定就是优化函数，可以是任何数据，其只取决于创建DictCache的时候传入的opts是什么
+    torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
+    opt.step()
+cache = DictCache([torch.device('cuda'), torch.device('cpu')],models,opts,3,opt_step, [cuda_models,cpu_models])
+
+# 训练:
+[md.train() for md in models]
+for inputs,targets in dataloader:
+    inputs,targets = inputs.cuda(),targets.cuda()
+    [opt.zero_grad() for opt in opts]
+    outs = cache.do_forward(lambda:real_model(inputs))
+    loss = loss_fn(outs, targets)
+    cache.do_backward(lambda: loss.backward())
+    # opt.step()在do_backward里会自动调用
+    print(loss.item())
+
+# 测试:
+inputs = torch.rand(1, dims).cuda()
+with torch.no_grad():
+    outputs = cache.do_forward(lambda:real_model(inputs))
+print(outputs)
+
+# 对比不用DictCache的时候
+# 注意：模型放入DictCache之后会挂上勾子函数，不再用DictCache的时要先调用DictCache的remove方法
+cache.remove()
+full_opt = optim.Adam(real_model.parameters(), lr=0.001)
+# 训练:
+real_model.cuda()
+real_model.train()
+for inputs,targets in dataloader:
+    inputs,targets = inputs.cuda(),targets.cuda()
+    full_opt.zero_grad()
+    outs = real_model(inputs)
+    loss = loss_fn(outs, targets)
+    loss.backward()
+    torch.nn.utils.clip_grad_norm_(real_model.parameters(), max_norm=1.0)
+    full_opt.step()
+    print(loss.item())
+
+pass
+
+# 测试:
+inputs = torch.rand(1, dims).cuda()
+with torch.no_grad():
+    outputs = real_model(inputs)
+print(outputs)
+

buildz-0.7.2/buildz/gpuz/test/report.txt

@@ -0,0 +1,107 @@
+
+测试结果: 
+训练模式大概能达到纯显卡（75W，更高的没测）二分之一或三分之一的性能，显存不够的可以用用
+
+环境: 
+    笔记本（游戏本）
+    显卡: RTX4060 8GB 75W残血版
+    CPU: i7-13700H
+    内存: 16GB
+
+1）线性层：
+训练模式：
+python -m buildz.gpuz.test.test_linear_demo train cuda,cache,cpu
+结果：
+data size: 0.457763671875 MB
+Model Size: 1.7890334129333496 GB
+Analyze
+    mean time cost not used DictCache: 4.274392604827881 sec
+    mean time cost using DictCache: 4.48450231552124 sec
+    mean time cost using CPU: 24.141416311264038 sec
+
+用不用DictCache耗时都是4秒左右，猜测是因为显存足够，可能转内存后显存还在哪里做了缓存
+先占掉4GB显存再测试：
+占用4GB显存（开另一个命令行窗口执行）
+python -m buildz.gpuz.test.take_gpu_mem 20
+时间测试（去掉cuda是因为显存不够，全部用cuda直接报错显存不足，根本用不了）：
+python -m buildz.gpuz.test.test_linear_demo train cache,cpu
+Analyze
+    mean time cost using DictCache: 12.55063670873642 sec
+    mean time cost using CPU: 23.80371403694153 sec
+
+用DictCache要12.6秒左右，性能推测是全部用显存的1/3，但起码比CPU快
+
+测试模式：
+python -m buildz.gpuz.test.test_linear_demo eval cuda,cache,cpu
+Analyze
+    mean time cost not used DictCache: 0.022499561309814453 sec
+    mean time cost using DictCache: 1.3205116987228394 sec
+    mean time cost using CPU: 0.3452974557876587 sec
+
+测试模式DictCache比CPU还慢，以测试结果为准，结论是测试模式线性层有显存用显存，没显存用CPU，尽量别用DictCache，具体原因不清楚
+
+2）卷积层：
+训练模式：
+python -m buildz.gpuz.test.test_resnet_demo train cuda,cache,cpu
+结果：
+data size: 60.0 MB
+Model Size: 2.75390625 MB
+Analyze
+    mean time cost not used DictCache: 4.0497170554267035 sec
+    mean time cost using DictCache: 8.11503267288208 sec
+    mean time cost using CPU: 60.47528860304091 sec
+CPU模式下卷积一直很慢，另外别看模型参数很小，全放显存的时候8GB显卡直接占满了
+
+显存占用一半后计算：
+python -m buildz.gpuz.test.take_gpu_mem 20
+#去掉cpu是因为显存对cpu没影响，没必要再测，去掉cuda到不是显存报错了，cuda能运行，但在显存不够的情况下，时间是两分钟左右，比cpu还慢，不测了
+python -m buildz.gpuz.test.test_linear_demo train cache
+Analyze
+    mean time cost using DictCache: 12.734953820705414 sec
+
+
+测试模式：
+python -m buildz.gpuz.test.test_resnet_demo eval cuda,cache,cpu
+Analyze
+    mean time cost not used DictCache: 2.141914208730062 sec
+    mean time cost using DictCache: 2.1802857451968722 sec
+    mean time cost using CPU: 18.77076021830241 sec
+
+显存足够，卷积层用不用DictCache感觉没啥差别，本来测试模式占用显存就少，不如不用DictCache
+
+多头注意力
+训练模式：
+python -m buildz.gpuz.test.test_resnet_demo train cuda,cache,cpu
+Analyze
+    mean time cost not used DictCache: 1.6817578077316284 sec
+    mean time cost using DictCache: 9.037651598453522 sec
+    mean time cost using CPU: 16.668074309825897 sec
+显存扣掉3GB
+python -m buildz.gpuz.test.take_gpu_mem 12
+python -m buildz.gpuz.test.test_resnet_demo train cuda,cache,cpu
+No Used DictCache
+ train: 0 mean loss: 7.049219369888306 time: 32.67351007461548
+ train: 1 mean loss: 6.776383876800537 time: 26.468174934387207
+ train: 2 mean loss: 6.425022125244141 time: 26.648658752441406
+ train: 3 mean loss: 6.085292339324951 time: 26.714829921722412
+ train: 4 mean loss: 5.76223087310791 time: 26.91315507888794
+Using DictCache:
+ train: 0 mean loss: 7.036778688430786 time: 14.886789083480835
+ train: 1 mean loss: 6.7514262199401855 time: 8.72349238395691
+ train: 2 mean loss: 6.392669439315796 time: 8.646085023880005
+看DictCache和之前差不多就没测完直接ctrl+C了，显存不够的时候，多头注意力全放显存比使用CPU还慢
+目前看卷积和多头注意力都有这种情况，在显存不够情况下和CPU差不多或者比CPU还慢，还不如用DictCache做下缓存
+
+测试模式:
+python -m buildz.gpuz.test.test_resnet_demo eval cuda,cache,cpu
+Analyze
+    mean time cost not used DictCache: 0.6104159355163574 sec
+    mean time cost using DictCache: 0.6807375550270081 sec
+    mean time cost using CPU: 6.312976717948914 sec
+
+
+如果是测试模式，显存不够的时候，可以部分模型全放显存，部分全放内存，建议是卷积和注意力多放显存，线性层多放内存，因为线性层占用空间大
+convs = [...]
+linears = [...]
+cache = DictCache(dvs=[torch.device('cuda'), torch.device('cpu')], dvs_nets = [convs, linears])
+...

{buildz-0.7.0 → buildz-0.7.2}/buildz/gpuz/test/take_gpu_mem.py

@@ -33,7 +33,7 @@ def test():
     mds,gmodel,opts,gop=fc_gen()
     ds = TestDataset(datas, dims)
     dl = DataLoader(ds, batch)
-    dt = list(dl)[0]
+    dt = list(dl)[0][0]
     gmodel = gmodel.cuda()
     with torch.no_grad():
         dt=dt.cuda()

buildz-0.7.2/buildz/gpuz/test/test_atten_demo.py

@@ -0,0 +1,165 @@
+#
+
+import sys
+from buildz.gpuz.torch import DictCache
+from buildz.gpuz.test import analyze
+from buildz import pyz
+import math
+import torch,time
+from torch import nn,optim
+from torch.utils.data import DataLoader, Dataset
+cpu,cuda = analyze.dvs
+MultiheadAttention = nn.MultiheadAttention
+class PostionalEncoding(nn.Module):
+    def __init__(self, word_size, max_length, batch_first=False):
+        super().__init__()
+        pos = torch.arange(max_length).unsqueeze(1)
+        words = torch.arange(word_size)
+        mod2 = words%2
+        offset = torch.pi*0.5*mod2
+        # exp(log(A)*B)等价于A^B
+        x = pos*torch.exp(-math.log(1e4)*(words-mod2)/word_size)
+        data = torch.sin(x+offset)
+        data.requires_grad=False
+        if batch_first:
+            data = data.unsqueeze(0)
+        else:
+            data = data.unsqueeze(1)
+        self.vecs = nn.Parameter(data, requires_grad=False)
+        self.batch_first = batch_first
+    def forward(self, ins):
+        if self.batch_first:
+            ins = ins + self.vecs[:, :ins.size(1)]
+        else:
+            ins = ins + self.vecs[:ins.size(1)]
+        return ins
+def make_linear(input_size, middle_size, middle_fc):
+    if middle_size is not None:
+        nets = []
+        nets.append(nn.Linear(input_size, middle_size))
+        if middle_fc is not None:
+            nets.append(middle_fc())
+        nets.append(nn.Linear(middle_size, input_size))
+        linear = nn.Sequential(*nets)
+    else:
+        linear = nn.Linear(input_size, input_size)
+    return linear
+class Decoder(nn.Module):
+    def __init__(self, word_dims, num_heads=1, kv_dims=None, batch_first=False, bias=True, linear_size=None, linear_fc = nn.ReLU):
+        super().__init__()
+        self.self_multi = MultiheadAttention(word_dims,num_heads,bias=bias,batch_first=batch_first,kdim=kv_dims,vdim=kv_dims)
+        self.linear = make_linear(word_dims, linear_size, linear_fc)
+        self.ln1 = nn.LayerNorm(word_dims)
+        self.ln2 = nn.LayerNorm(word_dims)
+        self.batch_first = batch_first
+    def forward(self, outputs, outs_mask):
+        self_attn, _ = self.self_multi(outputs,outputs,outputs, attn_mask=outs_mask)
+        outputs = self.ln1(outputs+self_attn)
+        outputs = self.ln2(outputs+self.linear(outputs)) 
+        return outputs
+class DecodePart(nn.Module):
+    def __init__(self, num_words, word_dims, sequence_length, num_decoders=6, num_heads=1, kv_dims=None, batch_first=False, bias=True, linear_size=None, linear_fc = nn.ReLU):
+        super().__init__()
+        self.embedding = nn.Embedding(num_words, word_dims)
+        self.pos_encoding = PostionalEncoding(word_dims, sequence_length, batch_first)
+        self.num_decoders = num_decoders
+        decoders = [Decoder(word_dims, num_heads, kv_dims, batch_first, bias, linear_size, linear_fc) for i in range(num_decoders)]
+        self.src_decoders = decoders
+        self.decoders = nn.ModuleList(decoders)
+    def mds(self):
+        return [self.embedding, self.pos_encoding]+self.src_decoders 
+    def forward(self, outputs, outs_mask):
+        outputs = self.embedding(outputs)
+        outputs = self.pos_encoding(outputs)
+        for decoder in self.decoders:
+            outputs = decoder(outputs, outs_mask)
+        return outputs
+class Chats(nn.Module):
+    def __init__(self, num_words_outputs, word_dims, sequence_length_outputs, num_decoders=6, num_heads=1, kv_dims=None, batch_first=False, bias=True, linear_size=None, linear_fc = nn.ReLU, mask_index = -1):
+        super().__init__()
+        self.decode = DecodePart(num_words_outputs, word_dims, sequence_length_outputs, num_decoders, num_heads, word_dims, batch_first, bias, linear_size, linear_fc)
+        self.linear = nn.Linear(word_dims, num_words_outputs)
+        self.sequence_length_outputs = sequence_length_outputs
+        self.mask_index = mask_index
+        self.batch_first = batch_first
+        self.num_heads = num_heads
+    def mds(self):
+        return [self.linear]+self.decode.mds()
+    def gen_masks(self, outputs):
+        if self.batch_first:
+            batch_id, dt_id=0,1
+        else:
+            batch_id, dt_id=1,0
+        batch_size, outs_len = outputs.size(batch_id), outputs.size(dt_id)
+        mask = torch.ones(batch_size, self.num_heads, outs_len, outs_len)
+        mask = torch.triu(mask, diagonal=1)
+        outs_mask = mask.to(torch.bool)
+        if self.mask_index>=0:
+            outs_mask_1 = (outputs==self.mask_index).unsqueeze(1).unsqueeze(1)
+            if not self.batch_first:
+                outs_mask_1 = outs_mask_1.transpose(0,3)
+            if self.num_heads>1 or outs_len>1:
+                outs_mask_1 = outs_mask_1.expand(batch_size, self.num_heads, outs_len, outs_len)
+            outs_mask = outs_mask | outs_mask_1
+        outs_mask = outs_mask.reshape(-1, outs_len, outs_len).bool().to(outputs.device)
+        return outs_mask
+    def forward(self, outputs):
+        outs_mask = self.gen_masks(outputs)
+        rst = self.decode(outputs, outs_mask)
+        rst = self.linear(rst)
+        return rst
+
+class TestDataset(Dataset):
+    def __init__(self, num, std_len, words):
+        self.num = num
+        self.datas = torch.randint(0, words, (num,std_len))
+        sz = analyze.sz(self.datas)
+        sz, unit = analyze.show_size(sz)
+        print(f"data size: {sz} {unit}")
+    def __len__(self):
+        return self.num
+    def __getitem__(self, i):
+        return self.datas[i], self.datas[i]
+
+pass
+
+def test():
+    num_words_outputs = 1024
+    word_dims = 512
+    sequence_length_outputs = 512
+    num_decoders=12
+    num_heads=8
+    loop = 5
+    num_datas = 60
+    batch=30
+    lr=0.0001
+    win_size=3
+    args = sys.argv[1:]
+    mark_train = True
+    if len(args)>0:
+        mark_train = args.pop(0).lower()=='train'
+    modes = 'cuda,cache,cpu'
+    if len(args)>0:
+        modes = args.pop(0)
+    if len(args)>0:
+        num_decoders = int(args.pop(0))
+    print(f"num_decoders: {num_decoders}")
+    ds = TestDataset(num_datas, sequence_length_outputs, num_words_outputs)
+    dl = DataLoader(ds, batch)
+    def fc_gen():
+        gmodel = Chats(num_words_outputs, word_dims, sequence_length_outputs, num_decoders, num_heads, batch_first=1)
+        mds = gmodel.mds()
+        opts =[optim.Adam(md.parameters(), lr=lr) for md in mds]
+        gopt = optim.Adam(gmodel.parameters(), lr=lr)
+        return mds, gmodel, opts, gopt
+    def fc_opt(net, opt):
+        torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
+        opt.step()
+    loss_fn = nn.CrossEntropyLoss()
+    def wrap_fn(outs, targets):
+        outs = outs.view(-1, outs.shape[-1])
+        targets = targets.reshape(-1)
+        return loss_fn(outs, targets)
+    analyze.analyzes(mark_train, loop, fc_gen, dl, wrap_fn, fc_opt, win_size, modes)
+
+pyz.lc(locals(),test)

{buildz-0.7.0 → buildz-0.7.2}/buildz/gpuz/test/test_linear_demo.py

@@ -33,7 +33,7 @@ class TestDataset(Dataset):
     def __len__(self):
         return self.n
     def __getitem__(self, i):
-        return self.datas[i]
+        return self.datas[i], self.datas[i]
 
 pass
 

buildz-0.7.2/buildz/gpuz/test/test_multi_demo.py

@@ -0,0 +1,147 @@
+#
+
+import sys
+from buildz.gpuz.torch import DictCache
+from buildz.gpuz.test import analyze
+from buildz import pyz
+import torch,time
+from torch import nn,optim
+from torch.utils.data import DataLoader, Dataset
+cpu,cuda = analyze.dvs
+class ConvModel(nn.Module):
+    def __init__(self, dims, ins_channels, middle_channels):
+        super().__init__()
+        nets=[]
+        nets.append(nn.Conv2d(ins_channels, middle_channels, 5, padding=2))
+        nets.append(nn.LeakyReLU())
+        self.nets = nn.Sequential(*nets)
+    def forward(self, inputs):
+        return self.nets(inputs)
+    def size(self):
+        return sum([analyze.unit_sz(net) for net in self.nets])
+
+pass
+class UNet(nn.Module):
+    def __init__(self, encoder, dealer, decoder):
+        super().__init__()
+        self.encoder, self.dealer, self.decoder = encoder, dealer, decoder
+    def forward(self, inputs):
+        tmp = self.encoder(inputs)
+        out = tmp
+        if self.dealer is not None:
+            out = self.dealer(tmp)
+        tmp = torch.cat([tmp, out], dim=1)
+        return self.decoder(tmp)
+class ResNet(nn.Module):
+    def __init__(self, net):
+        super().__init__()
+        self.net = net
+    def forward(self, inputs):
+        return inputs+self.net(inputs)
+class TestDataset(Dataset):
+    def __init__(self, num, dims, channels, outs_dims):
+        self.num = num
+        self.dims = dims
+        self.datas = torch.rand(num, channels, dims,dims)
+        self.targets = torch.rand(num, outs_dims)
+        sz = analyze.sz(self.datas)+analyze.sz(self.targets)
+        sz, unit = analyze.show_size(sz)
+        print(f"data size: {sz} {unit}")
+    def __len__(self):
+        return self.num
+    def __getitem__(self, i):
+        return self.datas[i], self.targets[i]
+
+pass
+class LnsNet(nn.Module):
+    def __init__(self, input_dims, outs_dims, num):
+        super().__init__()
+        curr_dims = input_dims
+        lns = []
+        for i in range(num):
+            rate = (i+1)/num
+            dims = int(input_dims*(1-rate)+outs_dims*rate)
+            ln = nn.Linear(curr_dims, dims)
+            lns.append(ln)
+            lns.append(nn.LeakyReLU())
+            curr_dims = dims
+        self.nets = nn.Sequential(*lns)
+    def forward(self, inputs):
+        batch = inputs.size(0)
+        inputs = inputs.reshape(batch, -1)
+        return self.nets(inputs)
+    def size(self):
+        return sum([analyze.unit_sz(net) for net in self.nets])
+
+def gen(dims, outs_dims, channels, num_conv, num_ln, lr):
+    """
+        类似UNet的模型，不过cat改成了resnet的加
+    """
+    mds = []
+    curr = channels
+    encoders = []
+    decoders = []
+    for i in range(num_conv):
+        encoder = ConvModel(dims, curr, curr*2)
+        decoder = ConvModel(dims, curr*4, curr)
+        curr*=2
+        encoders.append(encoder)
+        decoders.append(decoder)
+    base = None
+    mds += encoders
+    mds+=decoders
+    print(f"curr:{curr}")
+    for i in range(num_conv):
+        e = encoders[num_conv-i-1]
+        d = decoders[num_conv-i-1]
+        base = UNet(e, base, d)
+    cvnets = base
+    input_dims = dims*dims*channels
+    lns = LnsNet(input_dims, outs_dims, num_ln)
+    print(lns)
+    mds.append(lns)
+    gmds = [lns]
+    mds_sz = [md.size() for md in mds]
+    fullnet = nn.Sequential(cvnets, lns)
+    opts =[optim.Adam(md.parameters(), lr=lr) for md in mds]
+    gopt = optim.Adam(fullnet.parameters(), lr=lr)
+    sz, unit = analyze.show_size(sum(mds_sz))
+    print(f"Model Size: {sz} {unit}, mds: {len(mds)}")
+    return mds, fullnet, opts, gopt, [gmds, None]
+    
+
+
+def fc_opt(net, opt):
+    torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
+    opt.step()
+def test():
+    channels=3
+    dims= 32
+    out_dims = 10
+    loop = 10
+    datas = 6
+    batch=2
+    lr=0.0001
+    win_size=3
+    num_conv = 6
+    num_ln = 2
+    args = sys.argv[1:]
+    mark_train = True
+    if len(args)>0:
+        mark_train = args.pop(0).lower()=='train'
+    modes = 'cuda,cache,cpu'
+    if len(args)>0:
+        modes = args.pop(0)
+    if len(args)>0:
+        num_conv = int(args.pop(0))
+    if len(args)>0:
+        num_ln = int(args.pop(0))
+    print(f"num_conv: {num_conv}, num_ln: {num_ln}")
+    ds = TestDataset(datas, dims, channels, out_dims)
+    dl = DataLoader(ds, batch)
+    loss_fn = torch.nn.MSELoss()
+    def fc_gen():
+        return gen(dims, out_dims, channels, num_conv, num_ln, lr)
+    analyze.analyzes(mark_train, loop, fc_gen, dl, loss_fn, fc_opt, win_size, modes)
+
+pyz.lc(locals(),test)

{buildz-0.7.0 → buildz-0.7.2}/buildz/gpuz/test/test_resnet_demo.py

@@ -40,7 +40,7 @@ class TestDataset(Dataset):
     def __len__(self):
         return self.n
     def __getitem__(self, i):
-        return self.datas[i]
+        return self.datas[i], self.datas[i]
 
 pass
 def gen(dims, nets_num, channels, middle_channels, num_conv, lr):
@@ -99,6 +99,6 @@ def test():
     loss_fn = torch.nn.MSELoss()
     def fc_gen():
         return gen(dims, nets, channels, middle_channels, num_conv, lr)
-    analyze.analyzes(mark_train, loop, fc_gen, dl, loss_fn, fc_opt, win_size, 'cuda,cache,cpu')
+    analyze.analyzes(mark_train, loop, fc_gen, dl, loss_fn, fc_opt, win_size, modes)
 
 pyz.lc(locals(),test)

{buildz-0.7.0 → buildz-0.7.2}/buildz/gpuz/torch/__init__.py

@@ -5,5 +5,6 @@ __version__="0.0.1"
 __author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"
 # 小号多
 
-from .dict_middle import DictCache
+from .dict_middle import DictCache, Fcs
+#from .dict_middle import *
 Dict = DictCache