本文整理汇总了Python中nn.base.NNBase类的典型用法代码示例。如果您正苦于以下问题：Python NNBase类的具体用法？Python NNBase怎么用？Python NNBase使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了NNBase类的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的Python代码示例。
示例1: __init__
def __init__(self, L0, U0=None,
alpha=0.005, rseed=10, bptt=1):
self.hdim = L0.shape[1] # word vector dimensions |D|
self.vdim = L0.shape[0] # vocab size |V|
param_dims = dict(H = (self.hdim, self.hdim),
U = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
# Initialize word vectors
# either copy the passed L0 and U0 (and initialize in your notebook)
# or initialize with gaussian noise here
self.sparams.L = 0.1 * random.standard_normal(self.sparams.L.shape)
# self.params.U
self.params.U = 0.1 * random.standard_normal(self.params.U.shape)
# Initialize H matrix, as with W and U in part 1
# self.params.H = random_weight_matrix(*self.params.H.shape)
self.params.H = random_weight_matrix(*self.params.H.shape)
self.bptt = bptt
self.alpha = alpha
开发者ID:icodingc，项目名称:CS224d，代码行数:26，代码来源:rnnlm.py
示例2: __init__
def __init__(self, L0, U0=None,alpha=0.005, lreg = 0.00001, rseed=10, bptt=1):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
param_dims = dict(H = (self.hdim, self.hdim), W = (self.hdim,self.hdim))
#,U = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
self.alpha = alpha
self.lreg = lreg
#### YOUR CODE HERE ####
# Initialize word vectors
# either copy the passed L0 and U0 (and initialize in your notebook)
# or initialize with gaussian noise here
# Initialize H matrix, as with W and U in part 1
self.bptt = bptt
random.seed(rseed)
self.params.H = random_weight_matrix(*self.params.H.shape)
self.params.W = random_weight_matrix(*self.params.W.shape)
#self.params.U = 0.1*np.random.randn(*L0.shape)
self.sparams.L = L0.copy()
开发者ID:alphadl，项目名称:cs224d，代码行数:25，代码来源:rnnlmWithHierarchicalSoftmax.py
示例3: __init__
def __init__(self, L0, Dy=N_ASPECTS*SENT_DIM, U0=None,
alpha=0.005, rseed=10, bptt=5):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
self.ydim = Dy
param_dims = dict(H = (self.hdim, self.hdim),
U = (self.ydim, self.hdim),
b1 = (self.hdim,),
b2 =(self.ydim,))
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
var = .1
sigma = sqrt(var)
from misc import random_weight_matrix
random.seed(rseed)
# Initialize word vectors
self.bptt = bptt
self.alpha = alpha
self.params.H=random_weight_matrix(*self.params.H.shape)
if U0 is not None:
self.params.U= U0.copy()
else:
self.params.U= random_weight_matrix(*self.params.U.shape)
self.sparams.L = L0.copy()
self.params.b1 = zeros((self.hdim,))
self.params.b2 = zeros((self.ydim,))
开发者ID:laisun，项目名称:EntitySentiment，代码行数:30，代码来源:rnn_simple.py
示例4: __init__
def __init__(self, L0, U0=None,
alpha=0.005, rseed=10, bptt=1):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
param_dims = dict(H = (self.hdim, self.hdim),
U = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
# Initialize word vectors
# either copy the passed L0 and U0 (and initialize in your notebook)
# or initialize with gaussian noise here
# Initialize H matrix, as with W and U in part 1
self.sparams.L = L0.copy()
if U0 is None:
self.params.U = random.normal(0, 0.1, param_dims['U'])
else:
self.params.U = U0.copy()
self.params.H = random_weight_matrix(*param_dims['H'])
self.alpha = alpha
# self.rseed = rseed
self.bptt = bptt
开发者ID:ZhengXuxiao，项目名称:DLforNLP，代码行数:27，代码来源:rnnlm.py
示例5: __init__
def __init__(self, L0, U0=None,
alpha=0.005, rseed=10, bptt=1):
random.seed(rseed)
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
param_dims = dict(H = (self.hdim, self.hdim),
U = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
self.sparams.L = L0.copy()
self.params.H = random_weight_matrix(self.hdim, self.hdim)
self.alpha = alpha
self.bptt = bptt
# Initialize word vectors
# either copy the passed L0 and U0 (and initialize in your notebook)
# or initialize with gaussian noise here
if U0 is not None:
self.params.U = U0.copy()
else:
sigma = 0.1
mu = 0
#self.params.U = random.normal(mu, sigma, (self.vdim, self.hdim))
self.params.U = sigma*random.randn(self.vdim, self.hdim) + mu
开发者ID:janenie，项目名称:rnn_research，代码行数:28，代码来源:rnnlm.py
示例6: __init__
def __init__(self, L0, D0, U0=None,
alpha=0.005, rseed=10, bptt=1):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
self.ddim = D0.shape[0] # doc size
param_dims = dict(H = (self.hdim, self.hdim),
U = L0.shape, G = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape, D = D0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
self.bptt = bptt
self.alpha = alpha
# Initialize word vectors
self.sparams.L = L0.copy()
self.sparams.D = D0.copy()
self.params.U = random.randn(self.vdim, self.hdim)*0.1
# Initialize H matrix, as with W and U in part 1
self.params.H = random_weight_matrix(self.hdim, self.hdim)
self.params.G = random_weight_matrix(self.vdim, self.hdim)
开发者ID:afgiel，项目名称:docvec，代码行数:26，代码来源:drnnlm.py
示例7: __init__
def __init__(self, wv, dims=[100, 5],
reg=0.1, alpha=0.001,
rseed=10):
"""
Set up classifier: parameters, hyperparameters
"""
##
# Store hyperparameters
self.lreg = reg # regularization
self.alpha = alpha # default learning rate
self.nclass = dims[1] # number of output classes
##
# NNBase stores parameters in a special format
# for efficiency reasons, and to allow the code
# to automatically implement gradient checks
# and training algorithms, independent of the
# specific model architecture
# To initialize, give shapes as if to np.array((m,n))
param_dims = dict(W = (dims[1], dims[0]), # 5x100 matrix
b = (dims[1])) # column vector
# These parameters have sparse gradients,
# which is *much* more efficient if only a row
# at a time gets updated (e.g. word representations)
param_dims_sparse = dict(L=wv.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
##
# Now we can access the parameters using
# self.params.<name> for normal parameters
# self.sparams.<name> for params with sparse gradients
# and get access to normal NumPy arrays
self.sparams.L = wv.copy() # store own representations
self.params.W = random_weight_matrix(*self.params.W.shape)
开发者ID:kornev，项目名称:cs224d-hw2，代码行数:34，代码来源:softmax_example.py
示例8: __init__
def __init__(self, L0, U0=None,
alpha=0.005, rseed=10, bptt=1):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
param_dims = dict(H = (self.hdim, self.hdim),
U = (L0.shape if U0 is None else U0.shape))
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
self.alpha = alpha
self.bptt = bptt
# Initialize word vectors
# either copy the passed L0 and U0 (and initialize in your notebook)
# or initialize with gaussian noise here
random.seed(rseed)
sigma = sqrt(0.1)
self.sparams.L = random.normal(0, sigma, L0.shape)
self.params.U = random.normal(0, sigma, param_dims['U'])
# Initialize H matrix, as with W and U in part 1
self.params.H = random_weight_matrix(*param_dims['H'])
self.lamb = .0001 # regularization
开发者ID:arthur-tsang，项目名称:EqnMaster，代码行数:29，代码来源:rnnlm.py
示例9: __init__
def __init__(self, L0, U0=None,
alpha=0.005, rseed=10):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
param_dims = dict(LH = (self.hdim, self.hdim),
RH = (self.hdim, self.hdim),
U = (self.vdim, self.hdim * 2))
# note that only L gets sparse updates
param_dims_sparse = dict(LL = L0.shape, RL = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
np.random.seed(rseed) # be sure to seed this for repeatability!
self.alpha = alpha
# Initialize word vectors
# either copy the passed L0 and U0 (and initialize in your notebook)
# or initialize with gaussian noise here
#self.sparams.LL = np.random.randn(*L0.shape) * np.sqrt(0.1)
#self.sparams.RL = np.random.randn(*L0.shape) * np.sqrt(0.1)
self.sparams.LL = L0
self.sparams.RL = L0
self.params.U = np.random.randn(self.vdim, self.hdim*2) * np.sqrt(0.1)
# Initialize H matrix, as with W and U in part 1
self.params.LH = random_weight_matrix(self.hdim, self.hdim)
self.params.RH = random_weight_matrix(self.hdim, self.hdim)
开发者ID:nishithbsk，项目名称:SentenceGeneration，代码行数:28，代码来源:brnnlm.py
示例10: __init__
def __init__(self, L0, U0=None,
alpha=0.005, rseed=10, bptt=1):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
param_dims = dict(H = (self.hdim, self.hdim),
U = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
开发者ID:YunshengWei，项目名称:Deep-Learning-for-Natural-Language-Processing，代码行数:10，代码来源:rnnlm.py
示例11: grad_check
def grad_check(self, x, y, outfd=sys.stderr, **kwargs):
"""
Wrapper for gradient check on RNNs;
ensures that backprop-through-time is run to completion,
computing the full gradient for the loss as summed over
the input sequence and predictions.
Do not modify this function!
"""
NNBase.grad_check(self, x, y, outfd=outfd, **kwargs)
开发者ID:nishithbsk，项目名称:SentenceGeneration，代码行数:10，代码来源:brnnlm.py
示例12: __init__
def __init__(self, wv, windowsize=3,
dims=[None, 100, 5],
reg=0.001, alpha=0.01, rseed=10):
"""
Initialize classifier model.
Arguments:
wv : initial word vectors (array |V| x n)
note that this is the transpose of the n x |V| matrix L
described in the handout; you'll want to keep it in
this |V| x n form for efficiency reasons, since numpy
stores matrix rows continguously.
windowsize : int, size of context window
dims : dimensions of [input, hidden, output]
input dimension can be computed from wv.shape
reg : regularization strength (lambda)
alpha : default learning rate
rseed : random initialization seed
"""
# Set regularization
self.lreg = float(reg)
self.alpha = alpha # default training rate
dims[0] = windowsize * wv.shape[1] # input dimension
param_dims = dict(W=(dims[1], dims[0]),
b1=(dims[1],),
U=(dims[2], dims[1]),
b2=(dims[2],),
)
param_dims_sparse = dict(L=wv.shape)
# initialize parameters: don't change this line
NNBase.__init__(self, param_dims, param_dims_sparse)
random.seed(rseed) # be sure to seed this for repeatability!
#### YOUR CODE HERE ####
# any other initialization you need
#self.sparams， self.grads, self.param, self.sgrads
#where are they defined?
#为什么可以直接可以使用？
self.sparams.L = wv.copy()
#self.sparam.L = wv.copy()
self.params.U = random_weight_matrix(*param_dims["U"])
#self.param.U = random_weight_matrix(param_dims["U"])
self.params.W = random_weight_matrix(*param_dims["W"])
#self.param.b1 = zeros(param_dims["b1"])
#self.param.b2 = zeros(param_dims["b2"])
self.windowSize = windowsize
self.wordVecLen = wv.shape[1]
self.wordVecNum = wv.shape[0]
开发者ID:NeighborhoodWang，项目名称:CS224D-problem-set2，代码行数:52，代码来源:nerwindow.py
示例13: __init__
def __init__(self, wv, windowsize=3,
dims=[None, 100, 5],
reg=0.001, alpha=0.01, rseed=10):
"""
Initialize classifier model.
Arguments:
wv : initial word vectors (array |V| x n)
note that this is the transpose of the n x |V| matrix L
described in the handout; you'll want to keep it in
this |V| x n form for efficiency reasons, since numpy
stores matrix rows continguously.
windowsize : int, size of context window
dims : dimensions of [input, hidden, output]
input dimension can be computed from wv.shape
reg : regularization strength (lambda)
alpha : default learning rate
rseed : random initialization seed
"""
# Set regularization
self.lreg = float(reg)
self.alpha = alpha # default training rate
dims[0] = windowsize * wv.shape[1] # input dimension
param_dims = dict(W1=(dims[1], dims[0]), # 100 x 150
b2=(dims[1],), # 100 x 1
W2=(dims[2], dims[1]), # 5 X 100
b3=(dims[2],), # 5 x 1
)
param_dims_sparse = dict(L=wv.shape) # |V| x 50
# initialize parameters: don't change this line
NNBase.__init__(self, param_dims, param_dims_sparse)
random.seed(rseed) # be sure to seed this for repeatability!
#### YOUR CODE HERE ####
self.sparams.L = wv.copy();
self.params.W1 = random_weight_matrix(param_dims['W1'][0], param_dims['W1'][1])
self.params.b2 = append([], random_weight_matrix(param_dims['b2'][0], 1))
self.params.b3 = append([], random_weight_matrix(param_dims['b3'][0], 1))
self.params.W2 = random_weight_matrix(param_dims['W2'][0], param_dims['W2'][1])
self.n = wv.shape[1]
# informational
self.windowsize = windowsize
self.hidden_units = dims[1]
开发者ID:kireet，项目名称:cs224d，代码行数:50，代码来源:nerwindow.py
示例14: grad_check
def grad_check(self, x, y, outfd=sys.stderr, **kwargs):
"""
Wrapper for gradient check on RNNs;
ensures that backprop-through-time is run to completion,
computing the full gradient for the loss as summed over
the input sequence and predictions.
Do not modify this function!
"""
bptt_old = self.bptt
self.bptt = len(y)
print >> outfd, "NOTE: temporarily setting self.bptt = len(y) = %d to compute true gradient." % self.bptt
NNBase.grad_check(self, x, y, outfd=outfd, **kwargs)
self.bptt = bptt_old
print >> outfd, "Reset self.bptt = %d" % self.bptt
开发者ID:ryu577，项目名称:base，代码行数:14，代码来源:msushkov_rnnlm.py
示例15: __init__
def __init__(self, wv, windowsize=3,
dims=[None, 100, 5],
reg=0.001, alpha=0.01, rseed=10):
"""
Initialize classifier model.
Arguments:
wv : initial word vectors (array |V| x n)
note that this is the transpose of the n x |V| matrix L
described in the handout; you'll want to keep it in
this |V| x n form for efficiency reasons, since numpy
stores matrix rows continguously.
windowsize : int, size of context window
dims : dimensions of [input, hidden, output]
input dimension can be computed from wv.shape
reg : regularization strength (lambda)
alpha : default learning rate
rseed : random initialization seed
"""
# Set regularization
self.lreg = float(reg)
self.alpha = alpha # default training rate
#wv.shape: (100232,50)
dims[0] = windowsize * wv.shape[1] # input dimension 3*50=150
param_dims = dict(W=(dims[1], dims[0]),# W(100,150)
b1=(dims[1],),#b(100)
U=(dims[2], dims[1]),#U(5,100)
b2=(dims[2],),#(5,)
)
param_dims_sparse = dict(L=wv.shape) #L(100232,50)
# initialize parameters: don't change this line
NNBase.__init__(self, param_dims, param_dims_sparse)
random.seed(rseed) # be sure to seed this for repeatability!
#### YOUR CODE HERE ####
# any other initialization you need
self.sparams.L = wv.copy() # store own representations,100232,50 matrix
self.params.W = random_weight_matrix(*self.params.W.shape)
self.params.U = random_weight_matrix(*self.params.U.shape)
self.window_size = windowsize#3
self.word_vec_size = wv.shape[1]#50
开发者ID:Tang7，项目名称:rnn224，代码行数:46，代码来源:nerwindow.py
示例16: __init__
def __init__(self, L0, U0=None,
alpha=0.005, rseed=10, bptt=1):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
param_dims = dict(H = (self.hdim, self.hdim),
U = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
#random.seed(rseed)
self.params.U=0.1*random.randn(*self.params.U.shape)
self.sparams.L=0.1*random.randn(*self.sparams.L.shape)
self.params.H=random_weight_matrix(*self.params.H.shape)
self.bptt=bptt
self.alpha=alpha
开发者ID:nflsalex，项目名称:CS224D，代码行数:18，代码来源:rnnlm.py
示例17: __init__
def __init__(self, wv, windowsize=3,
dims=[None, 100, 5],
reg=0.001, alpha=0.01, rseed=10):
"""
Initialize classifier model.
Arguments:
wv : initial word vectors (array |V| x n) n=50
note that this is the transpose of the n x |V| matrix L
described in the handout; you'll want to keep it in
this |V| x n form for efficiency reasons, since numpy
stores matrix rows continguously.
windowsize : int, size of context window
dims : dimensions of [input, hidden, output]
input dimension can be computed from wv.shape
reg : regularization strength (lambda)
alpha : default learning rate
rseed : random initialization seed
"""
# Set regularization
self.lreg = float(reg)
self.alpha = alpha # default training rate
self.nclass = dims[2]
# input dimension, wv.shape is the dimension of each word vector representation
dims[0] = windowsize * wv.shape[1] # 50*3
param_dims = dict(W=(dims[1], dims[0]), # 100*150
b1=(dims[1]),
U=(dims[2], dims[1]),
b2=(dims[2]))
param_dims_sparse = dict(L=wv.shape) # L.shape = (|V|*50)
# initialize parameters: don't change this line
NNBase.__init__(self, param_dims, param_dims_sparse)
random.seed(rseed) # be sure to seed this for repeatability!
self.params.W = random_weight_matrix(*self.params.W.shape) # 100*150
self.params.U = random_weight_matrix(*self.params.U.shape) # 5*100
#self.params.b1 = zeros((dims[1],)) # 100*1
#self.params.b2 = zeros((self.nclass,)) # 5*1
self.sparams.L = wv.copy()
开发者ID:WenyingLiu，项目名称:cs224d，代码行数:44，代码来源:nerwindow.py
示例18: __init__
def __init__(self, wv, windowsize=3,
dims=[None, 100, 5],
reg=0.001, alpha=0.01, rseed=10):
"""
Initialize classifier model.
Arguments:
wv : initial word vectors (array |V| x n) => n is the input dimension, length of input word-vector
note that this is the transpose of the n x |V| matrix L
described in the handout; you'll want to keep it in
this |V| x n form for efficiency reasons, since numpy
stores matrix rows continguously.
windowsize : int, size of context window
dims : dimensions of [input, hidden, output]
input dimension can be computed from wv.shape
reg : regularization strength (lambda)
alpha : default learning rate
rseed : random initialization seed
"""
# Set regularization
self.lreg = float(reg)
self.alpha = alpha # default training rate
dims[0] = windowsize * wv.shape[1] # input dimension
param_dims = dict(W=(dims[1], dims[0]),
b1=(dims[1],),
U=(dims[2], dims[1]),
b2=(dims[2],),
)
param_dims_sparse = dict(L=wv.shape)
# initialize parameters
NNBase.__init__(self, param_dims, param_dims_sparse)
random.seed(rseed) # be sure to seed, re-show the result
# random initialization
self.sparams.L = wv.copy() # store own representations
self.params.U = random_weight_matrix(*self.params.U.shape)
self.params.W = random_weight_matrix(*self.params.W.shape)
self.window_size = windowsize
self.word_vec_size = wv.shape[1]
开发者ID:qcs4tracy，项目名称:NER-Project，代码行数:44，代码来源:nerwindow.py
示例19: __init__
def __init__(self, L0, U0=None,
alpha=0.005, lreg = 0.00001, rseed=10, bptt=1,loadData=False):
self.hdim = L0.shape[1] # word vector dimensions
self.vdim = L0.shape[0] # vocab size
param_dims = dict(H = (self.hdim, self.hdim), W = (self.hdim,self.hdim),
U = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
self.alpha = alpha
self.lreg = lreg
#### YOUR CODE HERE ####
# Initialize word vectors
# either copy the passed L0 and U0 (and initialize in your notebook)
# or initialize with gaussian noise here
# Initialize H matrix, as with W and U in part 1
self.bptt = bptt
if loadData == True:
with open("rnnlmWithW_hdim_150_bptt_4.H.npy") as fid:
H = pickle.load(fid)
self.params.H = H
with open("rnnlmWithW_hdim_150_bptt_4.W.npy") as fid:
W = pickle.load(fid)
self.params.W = W
with open("rnnlmWithW_hdim_150_bptt_4.U.npy") as fid:
U = pickle.load(fid)
self.params.U = U
with open("rnnlmWithW_hdim_150_bptt_4.L.npy") as fid:
L = pickle.load(fid)
self.sparams.L = L
return
random.seed(rseed)
self.params.H = random_weight_matrix(*self.params.H.shape)
self.params.W = random_weight_matrix(*self.params.W.shape)
self.params.U = 0.1*np.random.randn(*L0.shape)
self.sparams.L = L0.copy()
开发者ID:alphadl，项目名称:cs224d，代码行数:41，代码来源:rnnlm.py
示例20: __init__
def __init__(self, L0, U0=None,
alpha=0.005, rseed=10, bptt=1):
self.vdim = L0.shape[0] # vocab size
self.hdim = L0.shape[1] # word vector dimensions
param_dims = dict(H = (self.hdim, self.hdim),
U = L0.shape)
# note that only L gets sparse updates
param_dims_sparse = dict(L = L0.shape)
NNBase.__init__(self, param_dims, param_dims_sparse)
#### YOUR CODE HERE ####
# hyperparameters
self.bptt = bptt
self.alpha = alpha
# weights
self.sparams.L = random.normal(scale=sqrt(0.1), size=(self.vdim, self.hdim))
self.sparams.U = random.normal(scale=sqrt(0.1), size=(self.vdim, self.hdim))
self.params.H = random_weight_matrix(self.hdim, self.hdim)
开发者ID:hendrycks，项目名称:ML-Coursework，代码行数:21，代码来源:rnnlm.py
注：本文中的nn.base.NNBase类示例由纯净天空整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。 |
客服电话
APP下载
官方微信
请发表评论