Added tab2xml conversion
This commit is contained in:
parent
1686f5cc6f
commit
524ceeb4b6
137
sloleks_accentuation2_tab2xml.py
Normal file
137
sloleks_accentuation2_tab2xml.py
Normal file
|
|
@ -0,0 +1,137 @@
|
||||||
|
# Words proccesed: 650250
|
||||||
|
# Word indeks: 50023
|
||||||
|
# Word number: 50023
|
||||||
|
|
||||||
|
from lxml import etree
|
||||||
|
import time
|
||||||
|
from prepare_data import *
|
||||||
|
|
||||||
|
# def xml_words_generator(xml_path):
|
||||||
|
# for event, element in etree.iterparse(xml_path, tag="LexicalEntry", encoding="UTF-8"):
|
||||||
|
# words = []
|
||||||
|
# for child in element:
|
||||||
|
# if child.tag == 'WordForm':
|
||||||
|
# msd = None
|
||||||
|
# word = None
|
||||||
|
# for wf in child:
|
||||||
|
# if 'att' in wf.attrib and wf.attrib['att'] == 'msd':
|
||||||
|
# msd = wf.attrib['val']
|
||||||
|
# elif wf.tag == 'FormRepresentation':
|
||||||
|
# for form_rep in wf:
|
||||||
|
# if form_rep.attrib['att'] == 'zapis_oblike':
|
||||||
|
# word = form_rep.attrib['val']
|
||||||
|
# #if msd is not None and word is not None:
|
||||||
|
# # pass
|
||||||
|
# #else:
|
||||||
|
# # print('NOOOOO')
|
||||||
|
# words.append([word, '', msd, word])
|
||||||
|
# yield words
|
||||||
|
#
|
||||||
|
#
|
||||||
|
# gen = xml_words_generator('data/Sloleks_v1.2_p2.xml')
|
||||||
|
word_glob_num = 0
|
||||||
|
word_limit = 1000
|
||||||
|
iter_num = 1000
|
||||||
|
word_index = 0
|
||||||
|
|
||||||
|
# iter_index = 0
|
||||||
|
# words = []
|
||||||
|
#
|
||||||
|
# lexical_entries_load_number = 0
|
||||||
|
# lexical_entries_save_number = 0
|
||||||
|
#
|
||||||
|
# # INSIDE
|
||||||
|
# # word_glob_num = 1500686
|
||||||
|
# word_glob_num = 1550705
|
||||||
|
#
|
||||||
|
# # word_limit = 1500686
|
||||||
|
# word_limit = 1550705
|
||||||
|
#
|
||||||
|
# iter_index = 31
|
||||||
|
|
||||||
|
# done_lexical_entries = 33522
|
||||||
|
data = Data('s', shuffle_all_inputs=False)
|
||||||
|
accentuated_content = data._read_content('data/new_sloleks/new_sloleks.tab')
|
||||||
|
|
||||||
|
start_timer = time.time()
|
||||||
|
|
||||||
|
print('Copy initialization complete')
|
||||||
|
with open("data/new_sloleks/final_sloleks.xml", "ab") as myfile:
|
||||||
|
# myfile2 = open('data/new_sloleks/p' + str(iter_index) + '.xml', 'ab')
|
||||||
|
for event, element in etree.iterparse('data/Sloleks_v1.2.xml', tag="LexicalEntry", encoding="UTF-8", remove_blank_text=True):
|
||||||
|
# if word_glob_num >= word_limit:
|
||||||
|
# myfile2.close()
|
||||||
|
# myfile2 = open('data/new_sloleks/p' + str(iter_index) + '.xml', 'ab')
|
||||||
|
# iter_index += 1
|
||||||
|
# print("Words proccesed: " + str(word_glob_num))
|
||||||
|
#
|
||||||
|
# print("Word indeks: " + str(word_index))
|
||||||
|
# print("Word number: " + str(len(words)))
|
||||||
|
#
|
||||||
|
# # print("lexical_entries_load_number: " + str(lexical_entries_load_number))
|
||||||
|
# # print("lexical_entries_save_number: " + str(lexical_entries_save_number))
|
||||||
|
#
|
||||||
|
# end_timer = time.time()
|
||||||
|
# print("Elapsed time: " + "{0:.2f}".format((end_timer - start_timer) / 60.0) + " minutes")
|
||||||
|
lemma = ''
|
||||||
|
accentuated_word_location = ''
|
||||||
|
accentuated_word = ''
|
||||||
|
for child in element:
|
||||||
|
if child.tag == 'Lemma':
|
||||||
|
for wf in child:
|
||||||
|
if 'att' in wf.attrib and wf.attrib['att'] == 'zapis_oblike':
|
||||||
|
lemma = wf.attrib['val']
|
||||||
|
if child.tag == 'WordForm':
|
||||||
|
msd = None
|
||||||
|
word = None
|
||||||
|
for wf in child:
|
||||||
|
if 'att' in wf.attrib and wf.attrib['att'] == 'msd':
|
||||||
|
msd = wf.attrib['val']
|
||||||
|
elif wf.tag == 'FormRepresentation':
|
||||||
|
for form_rep in wf:
|
||||||
|
if form_rep.attrib['att'] == 'zapis_oblike':
|
||||||
|
word = form_rep.attrib['val']
|
||||||
|
# if msd is not None and word is not None:
|
||||||
|
# pass
|
||||||
|
# else:
|
||||||
|
# print('NOOOOO')
|
||||||
|
|
||||||
|
word_index = (word_index - 500) % len(accentuated_content)
|
||||||
|
word_index_sp = (word_index - 1) % len(accentuated_content)
|
||||||
|
while word_index != word_index_sp:
|
||||||
|
if word == accentuated_content[word_index][0] and msd == accentuated_content[word_index][2] and \
|
||||||
|
lemma == accentuated_content[word_index][1]:
|
||||||
|
accentuated_word_location = accentuated_content[word_index][4]
|
||||||
|
accentuated_word = accentuated_content[word_index][5][:-1]
|
||||||
|
del(accentuated_content[word_index])
|
||||||
|
break
|
||||||
|
word_index = (word_index + 1) % len(accentuated_content)
|
||||||
|
|
||||||
|
if word_index == word_index_sp:
|
||||||
|
print('ERROR IN ' + word + ' : ' + lemma + ' : ' + msd)
|
||||||
|
# print('ERROR IN ' + word + ' : ' + accentuated_content[word_index][0] + ' OR ' + msd + ' : '
|
||||||
|
# + accentuated_content[word_index][2])
|
||||||
|
# words.append([word, '', msd, word])
|
||||||
|
|
||||||
|
new_element = etree.Element('feat')
|
||||||
|
new_element.attrib['att'] = 'naglasna_mesta_besede'
|
||||||
|
new_element.attrib['val'] = accentuated_word_location
|
||||||
|
wf.append(new_element)
|
||||||
|
|
||||||
|
new_element = etree.Element('feat')
|
||||||
|
new_element.attrib['att'] = 'naglašena_beseda'
|
||||||
|
new_element.attrib['val'] = accentuated_word
|
||||||
|
wf.append(new_element)
|
||||||
|
word_glob_num += 1
|
||||||
|
# word_index += 1
|
||||||
|
|
||||||
|
# print(etree.tostring(element, encoding="UTF-8"))
|
||||||
|
# myfile2.write(etree.tostring(element, encoding="UTF-8", pretty_print=True))
|
||||||
|
if word_glob_num > word_limit:
|
||||||
|
print('Proccessed ' + str(word_glob_num) + ' words')
|
||||||
|
end_timer = time.time()
|
||||||
|
print("Elapsed time: " + "{0:.2f}".format((end_timer - start_timer) / 60.0) + " minutes")
|
||||||
|
word_limit += iter_num
|
||||||
|
break
|
||||||
|
myfile.write(etree.tostring(element, encoding="UTF-8", pretty_print=True))
|
||||||
|
element.clear()
|
||||||
|
|
@ -1,61 +0,0 @@
|
||||||
import numpy
|
|
||||||
import theano
|
|
||||||
import theano.tensor as T
|
|
||||||
rng = numpy.random
|
|
||||||
|
|
||||||
N = 400 # training sample size
|
|
||||||
feats = 784 # number of input variables
|
|
||||||
|
|
||||||
# generate a dataset: D = (input_values, target_class)
|
|
||||||
D = (rng.randn(N, feats), rng.randint(size=N, low=0, high=2))
|
|
||||||
training_steps = 10000
|
|
||||||
|
|
||||||
# Declare Theano symbolic variables
|
|
||||||
x = T.dmatrix("x")
|
|
||||||
y = T.dvector("y")
|
|
||||||
|
|
||||||
# initialize the weight vector w randomly
|
|
||||||
#
|
|
||||||
# this and the following bias variable b
|
|
||||||
# are shared so they keep their values
|
|
||||||
# between training iterations (updates)
|
|
||||||
w = theano.shared(rng.randn(feats), name="w")
|
|
||||||
|
|
||||||
# initialize the bias term
|
|
||||||
b = theano.shared(0., name="b")
|
|
||||||
|
|
||||||
print("Initial model:")
|
|
||||||
print(w.get_value())
|
|
||||||
print(b.get_value())
|
|
||||||
|
|
||||||
# Construct Theano expression graph
|
|
||||||
p_1 = 1 / (1 + T.exp(-T.dot(x, w) - b)) # Probability that target = 1
|
|
||||||
prediction = p_1 > 0.5 # The prediction thresholded
|
|
||||||
xent = -y * T.log(p_1) - (1-y) * T.log(1-p_1) # Cross-entropy loss function
|
|
||||||
cost = xent.mean() + 0.01 * (w ** 2).sum()# The cost to minimize
|
|
||||||
gw, gb = T.grad(cost, [w, b]) # Compute the gradient of the cost
|
|
||||||
# w.r.t weight vector w and
|
|
||||||
# bias term b
|
|
||||||
# (we shall return to this in a
|
|
||||||
# following section of this tutorial)
|
|
||||||
|
|
||||||
# Compile
|
|
||||||
train = theano.function(
|
|
||||||
inputs=[x,y],
|
|
||||||
outputs=[prediction, xent],
|
|
||||||
updates=((w, w - 0.1 * gw), (b, b - 0.1 * gb)))
|
|
||||||
predict = theano.function(inputs=[x], outputs=prediction)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
# Train
|
|
||||||
for i in range(training_steps):
|
|
||||||
pred, err = train(D[0], D[1])
|
|
||||||
|
|
||||||
print("Final model:")
|
|
||||||
print(w.get_value())
|
|
||||||
print(b.get_value())
|
|
||||||
print("target values for D:")
|
|
||||||
print(D[1])
|
|
||||||
print("prediction on D:")
|
|
||||||
print(predict(D[0]))
|
|
||||||
|
|
@ -1,82 +0,0 @@
|
||||||
import numpy
|
|
||||||
import theano
|
|
||||||
import theano.tensor as T
|
|
||||||
rng = numpy.random
|
|
||||||
|
|
||||||
N = 400 # training sample size
|
|
||||||
feats = 784 # number of input variables
|
|
||||||
|
|
||||||
# generate a dataset: D = (input_values, target_class)
|
|
||||||
D = (rng.randn(N, feats), rng.randint(size=N, low=0, high=2))
|
|
||||||
training_steps = 10000
|
|
||||||
|
|
||||||
# Declare Theano symbolic variables
|
|
||||||
x = T.dmatrix("x")
|
|
||||||
y = T.dvector("y")
|
|
||||||
|
|
||||||
# initialize the weight vector w randomly
|
|
||||||
#
|
|
||||||
# this and the following bias variable b
|
|
||||||
# are shared so they keep their values
|
|
||||||
# between training iterations (updates)
|
|
||||||
w = theano.shared(rng.randn(feats), name="w")
|
|
||||||
|
|
||||||
# initialize the bias term
|
|
||||||
b = theano.shared(0., name="b")
|
|
||||||
|
|
||||||
print("Initial model:")
|
|
||||||
print(w.get_value())
|
|
||||||
print(b.get_value())
|
|
||||||
|
|
||||||
# Construct Theano expression graph
|
|
||||||
p_1 = 1 / (1 + T.exp(-T.dot(x, w) - b)) # Probability that target = 1
|
|
||||||
prediction = p_1 > 0.5 # The prediction thresholded
|
|
||||||
xent = -y * T.log(p_1) - (1-y) * T.log(1-p_1) # Cross-entropy loss function
|
|
||||||
cost = xent.mean() + 0.01 * (w ** 2).sum()# The cost to minimize
|
|
||||||
gw, gb = T.grad(cost, [w, b]) # Compute the gradient of the cost
|
|
||||||
# w.r.t weight vector w and
|
|
||||||
# bias term b
|
|
||||||
# (we shall return to this in a
|
|
||||||
# following section of this tutorial)
|
|
||||||
|
|
||||||
|
|
||||||
def set_value_at_position(x, y, prediction, xent, w, b):
|
|
||||||
p_1 = 1 / (1 + T.exp(-T.dot(x, w) - b)) # Probability that target = 1
|
|
||||||
prediction = p_1 > 0.5 # The prediction thresholded
|
|
||||||
xent = -y * T.log(p_1) - (1 - y) * T.log(1 - p_1) # Cross-entropy loss function
|
|
||||||
cost = xent.mean() + 0.01 * (w ** 2).sum() # The cost to minimize
|
|
||||||
gw, gb = T.grad(cost, [w, b])
|
|
||||||
w = w - 0.1 * gw
|
|
||||||
b = b - 0.1 * gb
|
|
||||||
return w, b
|
|
||||||
|
|
||||||
|
|
||||||
result, updates = theano.scan(fn=set_value_at_position,
|
|
||||||
outputs_info=[prediction, xent],
|
|
||||||
sequences=[x, y],
|
|
||||||
non_sequences=[w, b],
|
|
||||||
n_steps=training_steps)
|
|
||||||
|
|
||||||
calculate_scan = theano.function(inputs=[x, y], outputs=[prediction, xent], updates=updates)
|
|
||||||
|
|
||||||
|
|
||||||
# Compile
|
|
||||||
train = theano.function(
|
|
||||||
inputs=[x,y],
|
|
||||||
outputs=[prediction, xent],
|
|
||||||
updates=((w, w - 0.1 * gw), (b, b - 0.1 * gb)))
|
|
||||||
predict = theano.function(inputs=[x], outputs=prediction)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
# Train
|
|
||||||
for i in range(training_steps):
|
|
||||||
pred, err = train(D[0], D[1])
|
|
||||||
|
|
||||||
print("Final model:")
|
|
||||||
print(w.get_value())
|
|
||||||
print(b.get_value())
|
|
||||||
print("target values for D:")
|
|
||||||
print(D[1])
|
|
||||||
print("prediction on D:")
|
|
||||||
print(predict(D[0]))
|
|
||||||
|
|
@ -1,105 +0,0 @@
|
||||||
import numpy as np
|
|
||||||
import theano.tensor as T
|
|
||||||
from theano import function
|
|
||||||
|
|
||||||
# ALGEBRA
|
|
||||||
x = T.dmatrix('x')
|
|
||||||
y = T.dmatrix('y')
|
|
||||||
z = x + y
|
|
||||||
f = function([x, y], z)
|
|
||||||
|
|
||||||
# print(f(2, 3))
|
|
||||||
# print(numpy.allclose(f(16.3, 12.1), 28.4))
|
|
||||||
print(f([[1, 2], [3, 4]], [[10, 20], [30, 40]]))
|
|
||||||
|
|
||||||
# exercise
|
|
||||||
import theano
|
|
||||||
a = T.vector() # declare variable
|
|
||||||
b = T.vector() # declare variable
|
|
||||||
out = a ** 2 + b ** 2 + 2 * a * b # build symbolic expression
|
|
||||||
f = function([a, b], out) # compile function
|
|
||||||
print(f([1, 2], [4, 5]))
|
|
||||||
|
|
||||||
###################################################
|
|
||||||
# OTHER EXAMPLES
|
|
||||||
|
|
||||||
# logistic function
|
|
||||||
x = T.dmatrix('x')
|
|
||||||
logistic_eq = 1 / (1 + T.exp(-x))
|
|
||||||
logistic = function([x], logistic_eq)
|
|
||||||
print(logistic([[0, 1], [-1, -2]]))
|
|
||||||
|
|
||||||
|
|
||||||
# multiple things calculation
|
|
||||||
a, b = T.dmatrices('a', 'b')
|
|
||||||
diff = a - b
|
|
||||||
abs_diff = abs(diff)
|
|
||||||
diff_squared = diff**2
|
|
||||||
f = function([a, b], [diff, abs_diff, diff_squared])
|
|
||||||
print(f([[1, 1], [1, 1]], [[0, 1], [2, 3]]))
|
|
||||||
|
|
||||||
|
|
||||||
# default value
|
|
||||||
c = T.matrix('c')
|
|
||||||
c = a + b
|
|
||||||
f = function([a, theano.In(b, value=[[1, 1], [1, 1]])], c)
|
|
||||||
print(f([[1, 1], [1, 1]]))
|
|
||||||
|
|
||||||
|
|
||||||
# accumulator
|
|
||||||
state = theano.shared([[0, 0], [0, 0]])
|
|
||||||
print("accumulator")
|
|
||||||
print(state.get_value())
|
|
||||||
|
|
||||||
|
|
||||||
state = theano.shared(np.matrix('0 0; 0 0', dtype=np.int32))
|
|
||||||
print(type(np.matrix('0 0; 0 0', dtype=np.int64)))
|
|
||||||
print(type(np.matrix('0 1; 2 3', dtype=np.int64)))
|
|
||||||
inc = T.imatrix('inc')
|
|
||||||
expression = state+inc
|
|
||||||
print(type(expression))
|
|
||||||
accumulator = function([inc], state, updates=[(state, state+inc)])
|
|
||||||
|
|
||||||
|
|
||||||
accumulator(np.matrix('1 2; 3 4', dtype=np.int32))
|
|
||||||
print(state.get_value())
|
|
||||||
accumulator(np.matrix('1 1; 1 1', dtype=np.int32))
|
|
||||||
print(state.get_value())
|
|
||||||
|
|
||||||
# function copy
|
|
||||||
print("function copy")
|
|
||||||
new_state = theano.shared(np.matrix('0 0; 0 0', dtype=np.int32))
|
|
||||||
new_accumulator = accumulator.copy(swap={state: new_state})
|
|
||||||
new_accumulator(np.matrix('1 2; 3 4', dtype=np.int32))
|
|
||||||
print(new_state.get_value())
|
|
||||||
print(state.get_value())
|
|
||||||
|
|
||||||
# random numbers
|
|
||||||
# POSSIBLE THAT THIS DOES NOT WORK ON GPU
|
|
||||||
print("random numbers")
|
|
||||||
srng = T.shared_randomstreams.RandomStreams(seed=234)
|
|
||||||
rv_u = srng.uniform((2, 2))
|
|
||||||
rv_n = srng.normal((2, 2))
|
|
||||||
f = function([], rv_u)
|
|
||||||
g = function([], rv_n, no_default_updates=True) # Not updating rv_n.rng
|
|
||||||
nearly_zeros = function([], rv_u + rv_u - 2 * rv_u)
|
|
||||||
|
|
||||||
print(f())
|
|
||||||
print(f())
|
|
||||||
|
|
||||||
print(g())
|
|
||||||
print(g())
|
|
||||||
|
|
||||||
print("sharing streams between functions")
|
|
||||||
state_after_v0 = rv_u.rng.get_value().get_state()
|
|
||||||
# nearly_zeros() # this affects rv_u's generator
|
|
||||||
v1 = f()
|
|
||||||
rng = rv_u.rng.get_value(borrow=True)
|
|
||||||
rng.set_state(state_after_v0)
|
|
||||||
rv_u.rng.set_value(rng, borrow=True)
|
|
||||||
v2 = f() # v2 != v1
|
|
||||||
v3 = f() # v3 == v1
|
|
||||||
|
|
||||||
print(v1)
|
|
||||||
print(v2)
|
|
||||||
print(v3)
|
|
||||||
|
|
@ -1,34 +0,0 @@
|
||||||
# if: (if(smth) else)
|
|
||||||
# switch: (if(smth) elif(smth))
|
|
||||||
|
|
||||||
from theano import tensor as T
|
|
||||||
from theano.ifelse import ifelse
|
|
||||||
import theano, time, numpy
|
|
||||||
|
|
||||||
a,b = T.scalars('a', 'b')
|
|
||||||
x,y = T.matrices('x', 'y')
|
|
||||||
|
|
||||||
z_switch = T.switch(T.lt(a, b), T.mean(x), T.mean(y))
|
|
||||||
z_lazy = ifelse(T.lt(a, b), T.mean(x), T.mean(y))
|
|
||||||
|
|
||||||
f_switch = theano.function([a, b, x, y], z_switch,
|
|
||||||
mode=theano.Mode(linker='vm'))
|
|
||||||
f_lazyifelse = theano.function([a, b, x, y], z_lazy,
|
|
||||||
mode=theano.Mode(linker='vm'))
|
|
||||||
|
|
||||||
val1 = 0.
|
|
||||||
val2 = 1.
|
|
||||||
big_mat1 = numpy.ones((10000, 1000))
|
|
||||||
big_mat2 = numpy.ones((10000, 1000))
|
|
||||||
|
|
||||||
n_times = 10
|
|
||||||
|
|
||||||
tic = time.clock()
|
|
||||||
for i in range(n_times):
|
|
||||||
f_switch(val1, val2, big_mat1, big_mat2)
|
|
||||||
print('time spent evaluating both values %f sec' % (time.clock() - tic))
|
|
||||||
|
|
||||||
tic = time.clock()
|
|
||||||
for i in range(n_times):
|
|
||||||
f_lazyifelse(val1, val2, big_mat1, big_mat2)
|
|
||||||
print('time spent evaluating one value %f sec' % (time.clock() - tic))
|
|
||||||
|
|
@ -1,94 +0,0 @@
|
||||||
import numpy as np
|
|
||||||
import theano
|
|
||||||
import theano.tensor as T
|
|
||||||
|
|
||||||
# normal gradient
|
|
||||||
x = T.dscalar('x')
|
|
||||||
z = T.dscalar('z')
|
|
||||||
y = x ** 3 + z ** 2
|
|
||||||
gy = T.grad(y, [x, z])
|
|
||||||
|
|
||||||
f = theano.function([x, z], gy)
|
|
||||||
|
|
||||||
# print(theano.pp(f.maker.fgraph.outputs[0]))
|
|
||||||
# print(theano.pp(f.maker.fgraph.outputs[1]))
|
|
||||||
|
|
||||||
print(f(4, 8))
|
|
||||||
|
|
||||||
# logistic gradient
|
|
||||||
x = T.dmatrix('x')
|
|
||||||
l = T.sum(1 / (1 + T.exp(-x)))
|
|
||||||
gl = T.grad(l, x)
|
|
||||||
|
|
||||||
f_lg = theano.function([x], gl)
|
|
||||||
|
|
||||||
print(f_lg([[0, 1], [-1, -2]]))
|
|
||||||
|
|
||||||
# np.matrix([[1, 2], [3, 4]])
|
|
||||||
|
|
||||||
# jacobian matrix
|
|
||||||
print('jacobian matrix1')
|
|
||||||
x = T.dvector('x')
|
|
||||||
y = x ** 2
|
|
||||||
J, updates = theano.scan(lambda i, y, x : T.grad(y[i], x), sequences=T.arange(y.shape[0]), non_sequences=[y, x])
|
|
||||||
f = theano.function([x], J, updates=updates)
|
|
||||||
print(f([1, 2, 3, 4, 5]))
|
|
||||||
|
|
||||||
# already implemented jacobian matrix
|
|
||||||
# W, V = T.dmatrices('W', 'V')
|
|
||||||
J = theano.gradient.jacobian(y, x)
|
|
||||||
f2 = theano.function([x], J)
|
|
||||||
print(f2([1, 2, 3, 4, 5]))
|
|
||||||
|
|
||||||
# jacobian matrix with matrix :)
|
|
||||||
W, V = T.dmatrices('W', 'V')
|
|
||||||
x = T.dvector('x')
|
|
||||||
y = T.dot(x, W)
|
|
||||||
J = theano.gradient.jacobian(y, W)
|
|
||||||
f2 = theano.function([W, x], J)
|
|
||||||
print(f2(np.array([[1, 1], [1, 1]]), np.array([0, 1])))
|
|
||||||
|
|
||||||
JV2 = T.dot(J, V)
|
|
||||||
f2 = theano.function([W, V, x], JV2)
|
|
||||||
print(f2(np.array([[1, 1], [1, 1]]), np.array([[2, 2], [2, 2]]), np.array([0, 1])))
|
|
||||||
|
|
||||||
|
|
||||||
print('jacobian matrix2')
|
|
||||||
x = T.dvector('x')
|
|
||||||
z = T.dvector('z')
|
|
||||||
y = x ** 2 + z ** 2
|
|
||||||
J, updates = theano.scan(lambda i, y, x, z: T.grad(y[i], [x, z]), sequences=T.arange(y.shape[0]), non_sequences=[y,x,z])
|
|
||||||
f = theano.function([x, z], J, updates=updates)
|
|
||||||
test = T.arange(y.shape[0])
|
|
||||||
t_f = theano.function([x, z], test)
|
|
||||||
print(f([4, 4], [1, 1]))
|
|
||||||
print(t_f([4, 4], [1, 1]))
|
|
||||||
|
|
||||||
# hessian matrix
|
|
||||||
x = T.dvector('x')
|
|
||||||
y = x ** 3
|
|
||||||
cost = y.sum()
|
|
||||||
gy = T.grad(cost, x)
|
|
||||||
H, updates = theano.scan(lambda i, gy, x : T.grad(gy[i], x), sequences=T.arange(gy.shape[0]), non_sequences=[gy, x])
|
|
||||||
f = theano.function([x], H, updates=updates)
|
|
||||||
print(f([4, 4]))
|
|
||||||
|
|
||||||
# jacobian times vector
|
|
||||||
|
|
||||||
# R-operator
|
|
||||||
W = T.dmatrix('W')
|
|
||||||
V = T.dmatrix('V')
|
|
||||||
x = T.dvector('x')
|
|
||||||
y = T.dot(x, W)
|
|
||||||
JV = T.Rop(y, W, V)
|
|
||||||
f = theano.function([W, V, x], JV)
|
|
||||||
print(f([[1, 1], [1, 1]], [[2, 2], [2, 2]], [0,1]))
|
|
||||||
|
|
||||||
# L-operator
|
|
||||||
W = T.dmatrix('W')
|
|
||||||
v = T.dvector('v')
|
|
||||||
x = T.dvector('x')
|
|
||||||
y = T.dot(x, W)
|
|
||||||
VJ = T.Lop(y, W, v)
|
|
||||||
f = theano.function([v,x], VJ)
|
|
||||||
print(f([2, 2], [0, 1]))
|
|
||||||
|
|
@ -1,100 +0,0 @@
|
||||||
import theano
|
|
||||||
import theano.tensor as T
|
|
||||||
|
|
||||||
k = T.iscalar("k")
|
|
||||||
A = T.vector("A")
|
|
||||||
|
|
||||||
# Symbolic description of the result
|
|
||||||
result, updates = theano.scan(fn=lambda prior_result, A: prior_result * A,
|
|
||||||
outputs_info=T.ones_like(A),
|
|
||||||
non_sequences=A,
|
|
||||||
n_steps=k)
|
|
||||||
|
|
||||||
# We only care about A**k, but scan has provided us with A**1 through A**k.
|
|
||||||
# Discard the values that we don't care about. Scan is smart enough to
|
|
||||||
# notice this and not waste memory saving them.
|
|
||||||
final_result = result[-1]
|
|
||||||
|
|
||||||
# compiled function that returns A**k
|
|
||||||
power = theano.function(inputs=[A,k], outputs=final_result, updates=updates)
|
|
||||||
|
|
||||||
print(power(range(10),2))
|
|
||||||
print(power(range(10),4))
|
|
||||||
|
|
||||||
print('P2:')
|
|
||||||
import numpy
|
|
||||||
|
|
||||||
coefficients = theano.tensor.vector("coefficients")
|
|
||||||
x = T.scalar("x")
|
|
||||||
|
|
||||||
max_coefficients_supported = 10000
|
|
||||||
|
|
||||||
# Generate the components of the polynomial
|
|
||||||
components, updates = theano.scan(fn=lambda coefficient, power, prior_result, free_variable: prior_result + (coefficient * (free_variable ** power)),
|
|
||||||
outputs_info=T.zeros(1),
|
|
||||||
sequences=[coefficients, theano.tensor.arange(max_coefficients_supported)],
|
|
||||||
non_sequences=x)
|
|
||||||
# Sum them up
|
|
||||||
polynomial = components.sum()
|
|
||||||
|
|
||||||
pol = components[-1]
|
|
||||||
|
|
||||||
# Compile a function
|
|
||||||
calculate_polynomial = theano.function(inputs=[coefficients, x], outputs=components)
|
|
||||||
|
|
||||||
# Test
|
|
||||||
test_coefficients = numpy.asarray([1, 0, 2], dtype=numpy.float32)
|
|
||||||
test_value = 3
|
|
||||||
print(calculate_polynomial(test_coefficients, test_value))
|
|
||||||
print(1.0 * (3 ** 0) + 0.0 * (3 ** 1) + 2.0 * (3 ** 2))
|
|
||||||
|
|
||||||
print('P3:')
|
|
||||||
import numpy as np
|
|
||||||
import theano
|
|
||||||
import theano.tensor as T
|
|
||||||
|
|
||||||
up_to = T.iscalar("up_to")
|
|
||||||
|
|
||||||
# define a named function, rather than using lambda
|
|
||||||
def accumulate_by_adding(arange_val, prior_result):
|
|
||||||
return prior_result + arange_val
|
|
||||||
seq = T.arange(up_to)
|
|
||||||
|
|
||||||
# An unauthorized implicit downcast from the dtype of 'seq', to that of
|
|
||||||
# 'T.as_tensor_variable(0)' which is of dtype 'int8' by default would occur
|
|
||||||
# if this instruction were to be used instead of the next one:
|
|
||||||
# outputs_info = T.as_tensor_variable(0)
|
|
||||||
|
|
||||||
outputs_info = T.as_tensor_variable(np.asarray(0, seq.dtype))
|
|
||||||
scan_result, scan_updates = theano.scan(fn=accumulate_by_adding,
|
|
||||||
outputs_info=outputs_info,
|
|
||||||
sequences=seq)
|
|
||||||
triangular_sequence = theano.function(inputs=[up_to], outputs=scan_result)
|
|
||||||
|
|
||||||
# test
|
|
||||||
some_num = 15
|
|
||||||
print(triangular_sequence(some_num))
|
|
||||||
print([n * (n + 1) // 2 for n in range(some_num)])
|
|
||||||
|
|
||||||
print('P4:')
|
|
||||||
location = T.imatrix("location")
|
|
||||||
values = T.vector("values")
|
|
||||||
output_model = T.matrix("output_model")
|
|
||||||
|
|
||||||
def set_value_at_position(a_location, a_value, output_model):
|
|
||||||
zeros = T.zeros_like(output_model)
|
|
||||||
zeros_subtensor = zeros[a_location[0], a_location[1]]
|
|
||||||
return T.set_subtensor(zeros_subtensor, a_value)
|
|
||||||
|
|
||||||
result, updates = theano.scan(fn=set_value_at_position,
|
|
||||||
outputs_info=None,
|
|
||||||
sequences=[location, values],
|
|
||||||
non_sequences=output_model)
|
|
||||||
|
|
||||||
assign_values_at_positions = theano.function(inputs=[location, values, output_model], outputs=result)
|
|
||||||
|
|
||||||
# test
|
|
||||||
test_locations = numpy.asarray([[1, 1], [2, 3]], dtype=numpy.int32)
|
|
||||||
test_values = numpy.asarray([42, 50], dtype=numpy.float32)
|
|
||||||
test_output_model = numpy.zeros((5, 5), dtype=numpy.float32)
|
|
||||||
print(assign_values_at_positions(test_locations, test_values, test_output_model))
|
|
||||||
Loading…
Reference in New Issue
Block a user