Skip to content

P
pytensor
提交 d2658923 authored 作者: Olivier Breuleux's avatar Olivier Breuleux
浏览文件
操作

some cleanup

上级 64b126df
隐藏空白字符变更
内嵌 并排
正在显示 包含 50 行增加 和 539 行删除
theano/sandbox/klass.py → theano/sandbox/module.py
浏览文件 @ d2658923
......@@ -105,17 +105,6 @@ class External(Component):
# class MemberInstance:
# def __init__(self, storage):
# self.storage = storage
# def get(self):
# return self.storage.value
# def set(self, value):
# self.storage.value = value
class Member(Component):
def __init__(self, r):
......@@ -131,7 +120,6 @@ class Member(Component):
def build(self, mode, memo):
return memo[self.r]
#return MemberInstance(memo[self.r])
def __set_name__(self, name):
super(Member, self).__set_name__(name)
......@@ -163,9 +151,7 @@ class Method(Component):
return result
def resolve_result(self, x):
if isinstance(x, gof.Result):# or \
#isinstance(x, compile.SymbolicInput) or \
#isinstance(x, compile.SymbolicInputKit):
if isinstance(x, gof.Result):
return x
else:
return self.resolve(x).r
......@@ -247,7 +233,6 @@ class CompositeInstance(object):
x.value = value
else:
x.initialize(value)
#raise TypeError('Cannot set this item: %s' % item)
def initialize(self, init):
for i, initv in enumerate(init):
......@@ -519,15 +504,6 @@ class KitComponent(Component):
memo[kit] = containers
return containers
# kit = self.kit
# if kit in memo:
# return memo[kit]
# rval = [gof.Container(input.result,
# storage = [None])
# for input in kit.sinputs]
# memo[kit] = rval
# return rval
def build(self, mode, memo):
return memo[self.kit]
......@@ -564,534 +540,69 @@ class RModule(FancyModule):
from theano import tensor as T
x, y = T.scalars('xy')
s = T.scalar()
s1, s2, s3 = T.scalars('s1', 's2', 's3')
#rterm = T.random.random_integers(T.shape(s), 100, 1000)
# print T.random.sinputs
# f = compile.function([x,
# ((s, s + x + rterm), 10),
# (T.random, 10)],
# s + x)
# print f[s]
# print f(10)
# print f[s]
mod = RModule()
mod.s = Member(s)
#mod.list = ComponentList(Member(s1), Member(s2))
#mod.list = [Member(s1), Member(s2)]
mod.list = [s1, s2]
mod.inc = Method(x, s + x,
s = mod.s + x + mod.random.random_integers((), 100, 1000))
mod.dec = Method(x, s - x,
s = s - x)
mod.sadd = Method([], s1 + mod.list[1])
m = mod.random.normal([], 1., 1.)
mod.test1 = Method([], m)
mod.test2 = Method([], m)
mod.whatever = 123
print mod._components
inst = mod.make(s = 2, list = [900, 9000])
inst.seed(10)
print inst.test1()
print inst.test1()
print inst.test2()
inst.seed(10)
print inst.test1()
print inst.test2()
print inst.s
inst.seed(10)
inst.inc(3)
print inst.s
inst.dec(4)
print inst.s
print inst.list[0]
print inst.list[1]
inst.list = [1, 2]
print inst.sadd()
inst.initialize(list = [10, -17])
print inst.sadd()
# class KlassComponent(object):
# _name = ""
# def bind(self, klass, name):
# if self.bound():
# raise Exception("%s is already bound to %s as %s" % (self, self.klass, self.name))
# self.klass = klass
# self.name = join(klass.name, name)
# def bound(self):
# return hasattr(self, 'klass')
# def __repr__(self):
# return str(self)
# def __str__(self):
# return self.__class__.__name__
# def __get_name__(self):
# return self._name
# def __set_name__(self, name):
# self._name = name
# name = property(lambda self: self.__get_name__(),
# lambda self, value: self.__set_name__(value))
# class KlassResult(KlassComponent):
# def __init__(self, r):
# self.r = r
# def __set_name__(self, name):
# super(KlassResult, self).__set_name__(name)
# self.r.name = name
# def __str__(self):
# return "%s(%s)" % (self.__class__.__name__, self.r)
# class KlassMember(KlassResult):
# def __init__(self, r):
# if r.owner:
# raise ValueError("A KlassMember must not be the result of a previous computation.")
# super(KlassMember, self).__init__(r)
# class KlassMethod(KlassComponent):
# def __init__(self, inputs, outputs, updates = {}, **kwupdates):
# if not isinstance(inputs, (list, tuple)):
# inputs = [inputs]
# self.inputs = inputs
# self.outputs = outputs
# self.updates = dict(updates, **kwupdates)
# def bind(self, klass, name):
# super(KlassMethod, self).bind(klass, name)
# self.inputs = [klass.resolve(i, KlassResult).r for i in self.inputs]
# self.outputs = [klass.resolve(o, KlassResult).r for o in self.outputs] \
# if isinstance(self.outputs, (list, tuple)) \
# else klass.resolve(self.outputs, KlassResult).r
# updates = self.updates
# self.updates = {}
# self.extend(updates)
# def extend(self, updates = {}, **kwupdates):
# if not hasattr(self, 'klass'):
# self.updates.update(updates)
# self.updates.update(kwupdates)
# else:
# for k, v in chain(updates.iteritems(), kwupdates.iteritems()):
# k, v = self.klass.resolve(k, KlassMember), self.klass.resolve(v, KlassResult)
# self.updates[k.r] = v.r
# def __str__(self):
# return "KlassMethod(%s -> %s%s%s)" % \
# (self.inputs,
# self.outputs,
# "; " if self.updates else "",
# ", ".join("%s <= %s" % (old, new) for old, new in self.updates.iteritems()))
# class Klass(KlassComponent):
# def __new__(cls, *args, **kwargs):
# self = object.__new__(cls)
# self.__dict__['__components__'] = {}
# self.__dict__['_name'] = ""
# self.__dict__['__components_list__'] = []
# self.__dict__['__component_names__'] = []
# return self
# ###
# ### Access to the klass members and methods
# ###
# def resolve(self, symbol, filter = None):
# if isinstance(symbol, gof.Result):
# if not filter or filter is KlassResult:
# return KlassResult(symbol)
# for component in self.__components_list__:
# if isinstance(component, Klass):
# try:
# return component.resolve(symbol, filter)
# except:
# continue
# if isinstance(component, KlassResult) and component.r is symbol:
# if filter and not isinstance(component, filter):
# raise TypeError('Did not find a %s instance for symbol %s in klass %s (found %s)'
# % (filter.__name__, symbol, self, type(component).__name__))
# return KlassResult(symbol)
# raise ValueError('%s is not part of this klass or any of its inner klasses. Please add it to the structure before you use it.' % symbol)
# elif isinstance(symbol, str):
# sp = split(symbol, 1)
# if len(sp) == 1:
# try:
# result = self.__components__[symbol]
# except KeyError:
# raise AttributeError('Could not resolve symbol %s in klass %s' % (symbol, self))
# if filter and not isinstance(result, filter):
# raise TypeError('Did not find a %s instance for symbol %s in klass %s (found %s)'
# % (filter.__name__, symbol, self, type(result).__name__))
# return result
# else:
# sp0, spr = sp
# klass = self.__components__[sp0]
# if not isinstance(klass, Klass):
# raise TypeError('Could not get subattribute %s of %s' % (spr, klass))
# return klass.resolve(spr, filter)
# else:
# raise TypeError('resolve takes a string or Result argument, not %s' % symbol)
# def members(self, as_results = False):
# filtered = [x for x in self.__components_list__ if isinstance(x, KlassMember)]
# if as_results:
# return [x.r for x in filtered]
# else:
# return filtered
# def methods(self):
# filtered = [x for x in self.__components_list__ if isinstance(x, KlassMethod)]
# return filtered
# def member_klasses(self):
# filtered = [x for x in self.__components_list__ if isinstance(x, Klass)]
# return filtered
# ###
# ### Make
# ###
# def __make__(self, mode, stor = None):
# if stor is None:
# stor = scratchpad()
# self.initialize_storage(stor)
# members = []
# methods = []
# rval = KlassInstance()
# for component, name in zip(self.__components_list__, self.__component_names__):
# if isinstance(component, KlassMember):
# container = getattr(stor, name)
# members.append((component, container))
# rval.__finder__[name] = container
# elif isinstance(component, Klass):
# inner, inner_members = component.__make__(mode, getattr(stor, name))
# rval.__dict__[name] = inner
# members += inner_members
# elif isinstance(component, KlassMethod):
# methods.append(component)
# for method in methods:
# inputs = list(method.inputs)
# for (component, container) in members:
# r = component.r
# update = method.updates.get(component.r, component.r)
# inputs.append(theano.In(result = r,
# update = update,
# value = container,
# name = r.name and split(r.name)[-1],
# mutable = True,
# strict = True))
# fn = theano.function(inputs,
# method.outputs,
# mode = mode)
# rval.__dict__[split(method.name)[-1]] = fn
# return rval, members
# def make(self, mode = 'FAST_RUN', **init):
# rval = self.__make__(mode)[0]
# self.initialize(rval, **init)
# return rval
# ###
# ### Instance setup and initialization
# ###
# def initialize_storage(self, stor):
# if not hasattr(stor, '__mapping__'):
# stor.__mapping__ = {}
# mapping = stor.__mapping__
# for name, component in self.__components__.iteritems():
# if isinstance(component, Klass):
# sp = scratchpad()
# setattr(stor, name, sp)
# sp.__mapping__ = mapping
# component.initialize_storage(sp)
# elif isinstance(component, KlassMember):
# r = component.r
# if r in mapping:
# container = mapping[r]
# else:
# container = gof.Container(r.type,
# name = name,
# storage = [None])
# mapping[r] = container
# setattr(stor, name, container)
# def initialize(self, inst, **init):
# for k, v in init.iteritems():
# inst[k] = v
# ###
# ### Magic methods and witchcraft
# ###
# def __setattr__(self, attr, value):
# if attr == 'name':
# self.__set_name__(value)
# return
# elif attr in ['_name', 'klass']:
# self.__dict__[attr] = value
# return
# if isinstance(value, gof.Result):
# value = KlassResult(value)
# if isinstance(value, KlassComponent):
# value.bind(self, attr)
# else:
# self.__dict__[attr] = value
# return
# self.__components__[attr] = value
# self.__components_list__.append(value)
# self.__component_names__.append(attr)
# if isinstance(value, KlassResult):
# value = value.r
# self.__dict__[attr] = value
# def __set_name__(self, name):
# orig = self.name
# super(Klass, self).__set_name__(name)
# for component in self.__components__.itervalues():
# if orig:
# component.name = join(name, component.name[len(orig):])
# else:
# component.name = join(name, component.name)
# def __str__(self):
# n = len(self.name)
# if n: n += 1
# member_names = ", ".join(x.name[n:] for x in self.members())
# if member_names: member_names = "members: " + member_names
# method_names = ", ".join(x.name[n:] for x in self.methods())
# if method_names: method_names = "methods: " + method_names
# klass_names = ", ".join(x.name[n:] for x in self.member_klasses())
# if klass_names: klass_names = "inner: " + klass_names
# return "Klass(%s)" % "; ".join(x for x in [self.name, member_names, method_names, klass_names] if x)
# class KlassInstance(object):
# def __init__(self):
# self.__dict__['__finder__'] = {}
# def __getitem__(self, attr):
# if isinstance(attr, str):
# attr = split(attr, 1)
# if len(attr) == 1:
# return self.__finder__[attr[0]].value
# else:
# return getattr(self, attr[0])[attr[1]]
# else:
# raise TypeError('Can only get an item via string format: %s' % attr)
# def __setitem__(self, attr, value):
# if isinstance(attr, str):
# attr = split(attr, 1)
# if len(attr) == 1:
# self.__finder__[attr[0]].value = value
# else:
# getattr(self, attr[0])[attr[1]] = value
# else:
# raise TypeError('Can only set an item via string format: %s' % attr)
# def __getattr__(self, attr):
# return self[attr]
# def __setattr__(self, attr, value):
# self[attr] = value
# # class Method(Component):
if __name__ == '__main__':
from theano import tensor as T
# # __priority__ = -1
x, y = T.scalars('xy')
s = T.scalar()
s1, s2, s3 = T.scalars('s1', 's2', 's3')
#rterm = T.random.random_integers(T.shape(s), 100, 1000)
# # def __init__(self, inputs, outputs, updates = {}, **kwupdates):
# # if not isinstance(inputs, (list, tuple)):
# # inputs = [inputs]
# # self._inputs = inputs
# # self._outputs = outputs
# # self._updates = dict(updates, **kwupdates)
# print T.random.sinputs
# # def bind(self, parent, name):
# # super(Method, self).bind(parent, name)
# # self.inputs = self.inputs
# # self.outputs = self.outputs
# # self.updates = self.updates
# f = compile.function([x,
# ((s, s + x + rterm), 10),
# (T.random, 10)],
# s + x)
# # def resolve(self, name):
# # if not self.bound():
# # raise ValueError('Trying to resolve a name on an unbound Method.')
# # result = self.parent.resolve(name)
# # if not hasattr(result, 'r'):
# # raise TypeError('Expected a Component with subtype Member or External.')
# # return result
# # def resolve_result(self, x):
# # if isinstance(x, str):
# # return self.resolve(x).r
# # else:
# # return x
# print f[s]
# print f(10)
# print f[s]
# # def set_inputs(self, inputs):
# # if not isinstance(outputs, (list, tuple)):
# # inputs = [inputs]
# # if not self.bound():
# # self._inputs = inputs
# # return
# # self._inputs = [self.resolve_result(input) for input in inputs]
# # def set_input(self, i, input):
# # if not self.bound():
# # self._inputs[i] = input
# # return
# # self._inputs[i] = self.resolve(input).r \
# # if isinstance(input, str) \
# # else input
# # def set_outputs(self, outputs):
# # if not self.bound():
# # self._outputs = outputs
# # return
# # if isinstance(outputs, (list, tuple)):
# # self._outputs = [self.resolve_result(output) for output in outputs]
# # else:
# # self._outputs = self.resolve_result(outputs)
mod = RModule()
mod.s = Member(s)
#mod.list = ComponentList(Member(s1), Member(s2))
#mod.list = [Member(s1), Member(s2)]
mod.list = [s1, s2]
mod.inc = Method(x, s + x,
s = mod.s + x + mod.random.random_integers((), 100, 1000))
mod.dec = Method(x, s - x,
s = s - x)
mod.sadd = Method([], s1 + mod.list[1])
# # def set_output(self, i, output):
# # if not self.bound():
# # self._outputs[i] = output
# # return
# # if not isinstance(self.outputs, (list, tuple)) and i == 0:
# # self.set_outputs(output)
# # else:
# # self._outputs[i] = self.resolve_result(output)
m = mod.random.normal([], 1., 1.)
mod.test1 = Method([], m)
mod.test2 = Method([], m)
# # def set_updates(self, updates):
# # self._updates = {}
# # self.add_updates(updates)
mod.whatever = 123
# # def add_updates(self, updates = {}, **kwupdates):
# # if not self.bound():
# # self.updates.update(updates)
# # self.updates.update(kwupdates)
# # else:
# # for k, v in chain(updates.iteritems(), kwupdates.iteritems()):
# # k, v = self.resolve_result(k), self.resolve_result(v)
# # self.updates[k] = v
print mod._components
# # inputs = property(lambda self: self._inputs, set_inputs)
# # outputs = property(lambda self: self._outputs, set_outputs)
# # updates = property(lambda self: self._updates, set_updates)
inst = mod.make(s = 2, list = [900, 9000])
# # def __str__(self):
# # return "Method(%s -> %s%s%s)" % \
# # (self.inputs,
# # self.outputs,
# # "; " if self.updates else "",
# # ", ".join("%s <= %s" % (old, new) for old, new in self.updates.iteritems()))
inst.seed(10)
print inst.test1()
print inst.test1()
print inst.test2()
inst.seed(10)
print inst.test1()
print inst.test2()
print inst.s
inst.seed(10)
inst.inc(3)
print inst.s
inst.dec(4)
print inst.s
print inst.list[0]
print inst.list[1]
inst.list = [1, 2]
# # self.inputs = [parent.resolve(i).r for i in self.inputs]
# # self.outputs = [parent.resolve(o).r for o in self.outputs] \
# # if isinstance(self.outputs, (list, tuple)) \
# # else parent.resolve(self.outputs, KlassResult).r
# # updates = self.updates
# # self.updates = {}
# # self.extend(updates)
print inst.sadd()
inst.initialize(list = [10, -17])
print inst.sadd()
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论