本文整理汇总了Python中vector_palabras.palabras_comunes函数的典型用法代码示例。如果您正苦于以下问题：Python palabras_comunes函数的具体用法？Python palabras_comunes怎么用？Python palabras_comunes使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了palabras_comunes函数的13个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: palabras_comunes
from vector_palabras import palabras_comunes
from random import uniform
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np
window_size = 11 # Cantidad de palabras en cada caso de prueba
unidades_ocultas_capa_2 = 50
unidades_ocultas_capa_3 = 1
file_length = 10
archivo_embedding = "embedding/embedding_total.txt"
# Cargo embedding inicial
palabras = palabras_comunes(archivo_embedding) # Indice de cada palabra en el diccionario
embedding_inicial=[]
for l in open(archivo_embedding):
embedding_inicial.append([float(x) for x in l.split()[1:]])
vector_size = len(embedding_inicial[0]) # Cantidad de features para cada palabra. Coincide con la cantidad de hidden units de la primer capa
print 'Cantidad de features considerados: ' + str(vector_size)
# Agregamos embedding para PUNCT inicializado como el mismo embedding que ':'
indice_punct_base = palabras.obtener_indice(':')
embedding_inicial.append(list(embedding_inicial[indice_punct_base]))
# todo: agregar DATE y signos de puntuacion
# Agregamos embedding para OUT, NUM y UNK示例2: str
archivo_loss = './loss.png'
learning_rate = 0.8
momentum = 0.1
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTarea: Chunking'
log += '\nModelo de red: Ventana'
log += '\nEmbedding inicial: Aleatorio'
log += '\nIOBES: Unido'
log += '\nActivacion: relu'
log += '\nLearning Rate / Momentum: ' + str(learning_rate) + ' / ' + str(momentum)
log += '\nOUT tag: SI'
print 'Cargando embedding inicial...'
# Cargo embedding inicial
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
# Defino las capas de la red
# https://blog.keras.io/using-pre-trained-word-embeddings-in-a-keras-model.html
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
input_length=window_size, trainable=True)
second_layer = Dense(units=unidades_ocultas_capa_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=None),
bias_initializer=Constant(value=0.1))
示例3: palabras_comunes
from vector_palabras import palabras_comunes
from random import random
import tensorflow as tf
import csv
csv.field_size_limit(sys.maxsize)
window_size = 11 # Cantidad de palabras en cada caso de prueba
vector_size = 50 # Cantidad de features para cada palabra. Coincide con la cantidad de hidden units de la primer capa
cant_palabras = 55004 # Cantidad de palabras consideradas en el diccionario
unidades_ocultas_capa_2 = 100
unidades_ocultas_capa_3 = 1
file_length = 10
p = palabras_comunes("es-lexicon.txt")
def generar_vectores_iniciales(cantidad, tamano):
lista_vectores = []
for i in range (0, cantidad):
vector = []
for k in range(0, tamano):
vector.append(random())
lista_vectores.append(vector)
return lista_vectores
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):示例4: main
def main(supertag = 0, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
window_size = 11 # Cantidad de palabras en cada caso de prueba
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
# Defino las tareas a entrenar...
supertags = ['supertag_compacto', 'supertag']
nombre_tareas = ['microchunking', 'macrochunking', 'ner', 'pos', supertags[supertag]]
tareas = []
inicio_carga_casos = time.time()
for t in nombre_tareas:
tareas.append(Tarea(t))
duracion_carga_casos = time.time() - inicio_carga_casos
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTESTING'
log += '\nTareas: ' + str(nombre_tareas)
log += '\nModelo de red: Ventana'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nActivacion: relu'
log += '\nOptimizador: adam'
print 'Compilando red...'
# Defino las capas de la red
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
input_length=window_size, trainable=True)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=1),
input_length=window_size, trainable=True)
second_layer = Dense(units=unidades_ocultas_capa_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=2),
bias_initializer=Constant(value=0.1))
# Agrego las capas a los modelos
for t in tareas:
t.model.add(embedding_layer)
t.model.add(Flatten())
t.model.add(second_layer)
t.model.add(Activation("relu"))
third_layer = Dense(units=t.unidades_ocultas_capa_3,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=3),
bias_initializer=Constant(value=0.1))
t.model.add(third_layer)
t.model.add(Activation("softmax"))
t.model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
t.model.summary
# Obtengo metricas
print 'Obteniendo metricas...'
inicio_metricas = time.time()
for t in tareas:
t.model.load_weights(t.archivo_best)
t.obtenerMetricas()
duracion_metricas = time.time() - inicio_metricas
# Escribo en log
log += '\n\nTiempo de carga de casos de Prueba: {0} hs, {1} min, {2} s'.format(int(duracion_carga_casos/3600),int((duracion_carga_casos % 3600)/60),int((duracion_carga_casos % 3600) % 60))
np.set_printoptions(threshold=10000, edgeitems=1000, linewidth=100000)
for t in tareas:
log += '\n\n' + t.nombre.upper() + '\n--------'
log += '\n\nAccuracy: ' + str(t.accuracy)
#.........这里部分代码省略.........
示例5: main
def main(supertag = 0, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
vector_size_distancia = 5 # Cantidad de features para representar la distancia a la palabra a etiquetar
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
unidades_ocultas_capa_2_2 = 500
# Defino las tareas a entrenar...
supertags= ['supertag_compacto', 'supertag']
#nombre_tareas = ['microchunking', 'macrochunking', 'ner', 'pos', 'srl', supertags[supertag]]
nombre_tareas = [supertags[supertag]]
tareas = []
inicio_carga_casos = time.time()
for t in nombre_tareas:
tareas.append(Tarea(t))
duracion_carga_casos = time.time() - inicio_carga_casos
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTESTING'
log += '\nTareas: ' + str(nombre_tareas)
log += '\nModelo de red: Convolutiva'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nActivacion: relu'
log += '\nOptimizador: adam'
print 'Compilando red...'
# Defino las capas de la red
main_input = Input(shape=(largo_sentencias,), name='main_input')
aux_input_layer = Input(shape=(largo_sentencias,), name='aux_input')
distance_embedding_layer = Embedding(input_dim=100, output_dim=vector_size_distancia,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=4),
trainable=True)(aux_input_layer)
aux_input_layer2 = Input(shape=(largo_sentencias,), name='aux_input2')
distance_embedding_layer2 = Embedding(input_dim=100, output_dim=vector_size_distancia,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=5),
trainable=True)(aux_input_layer2)
concat_layer_aux = Concatenate()([distance_embedding_layer, distance_embedding_layer2])
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
trainable=True)(main_input)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=1),
trainable=True)(main_input)
concat_layer = Concatenate()([embedding_layer, concat_layer_aux])
convolutive_layer = Conv1D(filters=unidades_ocultas_capa_2, kernel_size=5)(concat_layer)
x_layer = GlobalMaxPooling1D()(convolutive_layer)
second_layer = Dense(units=unidades_ocultas_capa_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=2),
bias_initializer=Constant(value=0.1))(x_layer)
y_layer = Activation("tanh")(second_layer)
inputs = [main_input, aux_input_layer, aux_input_layer2]
for t in tareas:
if t.srl:
second_layer_2 = Dense(units=unidades_ocultas_capa_2_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=6),
#.........这里部分代码省略.........
示例6: main
def main(supertag = 0, cant_iteraciones = 20, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
window_size = 11 # Cantidad de palabras en cada caso de prueba
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
# Defino las tareas a entrenar...
supertags = ['supertag_compacto', 'supertag']
nombre_tareas = ['microchunking', 'macrochunking', 'ner', 'pos', supertags[supertag]]
tareas = []
inicio_carga_casos = time.time()
for t in nombre_tareas:
tareas.append(Tarea(t, cant_iteraciones))
duracion_carga_casos = time.time() - inicio_carga_casos
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTareas: ' + str(nombre_tareas)
log += '\nModelo de red: Ventana'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nActivacion: relu'
log += '\nOptimizador: adam'
print 'Compilando red...'
# Defino las capas de la red
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
input_length=window_size, trainable=True)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=1),
input_length=window_size, trainable=True)
second_layer = Dense(units=unidades_ocultas_capa_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=2),
bias_initializer=Constant(value=0.1))
# Agrego las capas a los modelos
for t in tareas:
t.model.add(embedding_layer)
t.model.add(Flatten())
t.model.add(second_layer)
t.model.add(Activation("relu"))
third_layer = Dense(units=t.unidades_ocultas_capa_3,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=3),
bias_initializer=Constant(value=0.1))
t.model.add(third_layer)
t.model.add(Activation("softmax"))
t.model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
t.model.summary
print 'Entrenando...'
# Calculo valores iniciales
for t in tareas:
t.evaluar()
# Cargo en una variable de control el valor de val_acc de la tarea de SuperTagging
mejor_acc = tareas[-1].history['val_acc'][0]
# Escribo en un archivo los pesos iniciales de las redes
for t in tareas:
t.model.save_weights(t.archivo_best)
inicio_entrenamiento = time.time()
for i in range(cant_iteraciones):
print 'Iteracion: ' + str(i+1)
for j in range(divisor):
#print_progress(j, divisor)
for t in tareas:
_ = t.model.fit(t.x_train[t.largo_batch*j: t.largo_batch*(j+1)], t.y_train[t.largo_batch*j: t.largo_batch*(j+1)],
#.........这里部分代码省略.........
示例7: main
def main(tarea, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
archivo_corpus_pruebas = path_proyecto + '/corpus/Sentencia/Testing/' + tarea + '_testing.csv'
vector_size_distancia = 5 # Cantidad de features para representar la distancia a la palabra a etiquetar
largo_sentencias = 50
def cargarCasos(archivo):
# Abro el archivo
x = []
y = []
with open(archivo, 'rb') as archivo_csv:
lector = csv.reader(archivo_csv, delimiter=',')
for linea in lector:
largo_x = largo_sentencias + 2
x.append([int(t) for t in linea[:largo_x]])
y.append([int(t) for t in linea[largo_x:]])
x_a = [l[2:] for l in x]
x_b = [ [largo_sentencias+i-l[0] for i in range(largo_sentencias)] for l in x] # Matriz que almacenara distancias a la palabra a analizar
x_a = np.array(x_a)
x_b = np.array(x_b)
x_c = [ [largo_sentencias+i-l[1] for i in range(largo_sentencias)] for l in x] # Matriz que almacenara distancias a la palabra a analizar
x_c = np.array(x_c)
y = np.array(y)
print y[0]
return x_a, x_b, x_c, y
# Cargo casos
inicio_carga_casos = time.time()
print 'Cargando casos de prueba...'
x_test_a, x_test_b, x_test_c, y_test = cargarCasos(archivo_corpus_pruebas)
duracion_carga_casos = time.time() - inicio_carga_casos
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
unidades_ocultas_capa_2_2 = 500
unidades_ocultas_capa_3 = len(y_test[0])
archivo_best = 'mejores_pesos.hdf5'
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTESTING'
log += '\nTarea: ' + tarea
log += '\nModelo de red: Convolutiva'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nOptimizer: adam'
log += '\nActivacion: relu'
print 'Compilando red...'
# Defino las capas de la red
main_input = Input(shape=(largo_sentencias,), name='main_input')
aux_input_layer = Input(shape=(largo_sentencias,), name='aux_input')
distance_embedding_layer = Embedding(input_dim=largo_sentencias*2, output_dim=vector_size_distancia,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=4),
trainable=True)(aux_input_layer)
aux_input_layer2 = Input(shape=(largo_sentencias,), name='aux_input2')
distance_embedding_layer2 = Embedding(input_dim=largo_sentencias*2, output_dim=vector_size_distancia,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=5),
trainable=True)(aux_input_layer2)
concat_layer_aux = Concatenate()([distance_embedding_layer, distance_embedding_layer2])
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
trainable=True)(main_input)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
#.........这里部分代码省略.........
示例8: main
def main(tarea, cantidad_iteraciones = 20, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
archivo_corpus_entrenamiento = path_proyecto + '/corpus/separadas/Sentencia/' + tarea + '_training.csv'
archivo_corpus_pruebas = path_proyecto + '/corpus/Sentencia/Desarrollo/' + tarea + '_pruebas.csv'
vector_size_distancia = 5 # Cantidad de features para representar la distancia a la palabra a etiquetar
largo_sentencias = 50
def cargarCasos(archivo, extra=False):
# Abro el archivo
x = []
y = []
with open(archivo, 'rb') as archivo_csv:
lector = csv.reader(archivo_csv, delimiter=',')
for linea in lector:
largo_x = largo_sentencias + 1
x.append([int(t) for t in linea[:largo_x]])
y.append([int(t) for t in linea[largo_x:]])
x_a = [l[1:] for l in x]
x_b = [ [largo_sentencias+i-l[0] for i in range(largo_sentencias)] for l in x] # Matriz que almacenara distancias a la palabra a analizar
x_a = np.array(x_a)
x_b = np.array(x_b)
y = np.array(y)
print y[0]
return x_a, x_b, y
# Cargo casos
inicio_carga_casos = time.time()
print 'Cargando casos de entrenamiento...'
x_train_a, x_train_b, y_train = cargarCasos(archivo_corpus_entrenamiento)
print 'Cargando casos de prueba...'
x_test_a, x_test_b, y_test = cargarCasos(archivo_corpus_pruebas)
duracion_carga_casos = time.time() - inicio_carga_casos
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
unidades_ocultas_capa_2_2 = 500
unidades_ocultas_capa_3 = len(y_train[0])
archivo_best = 'mejores_pesos.hdf5'
archivo_acc = './accuracy.png'
archivo_loss = './loss.png'
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTarea: ' + tarea
log += '\nModelo de red: Convolutiva'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nOptimizer: adam'
log += '\nActivacion: relu'
print 'Compilando red...'
# Defino las capas de la red
main_input = Input(shape=(largo_sentencias,), name='main_input')
aux_input_layer = Input(shape=(largo_sentencias,), name='aux_input')
distance_embedding_layer = Embedding(input_dim=largo_sentencias*2, output_dim=vector_size_distancia,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=4),
trainable=True)(aux_input_layer)
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
trainable=True)(main_input)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=1),
#.........这里部分代码省略.........
示例9: main
def main(tarea, cantidad_iteraciones = 20, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
archivo_corpus_entrenamiento = path_proyecto + '/corpus/separadas/Ventana/' + tarea + '_training.csv'
archivo_corpus_pruebas = path_proyecto + '/corpus/Ventana/Desarrollo/' + tarea + '_pruebas.csv'
def cargarCasos(archivo):
# Abro el archivo
df = pd.read_csv(archivo, sep=',', skipinitialspace=True, header=None, quoting=3)
largo = len(df)
# Separo features de resultados esperados
x = np.array(df.iloc[:largo,:11])
y = np.array(df.iloc[:largo,11:])
return x, y
# Cargo casos
inicio_carga_casos = time.time()
print 'Cargando casos de entrenamiento...'
x_train, y_train = cargarCasos(archivo_corpus_entrenamiento)
print 'Cargando casos de prueba...'
x_test, y_test = cargarCasos(archivo_corpus_pruebas)
duracion_carga_casos = time.time() - inicio_carga_casos
window_size = 11 # Cantidad de palabras en cada caso de prueba
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
unidades_ocultas_capa_3 = len(y_train[0])
archivo_best = 'mejores_pesos.hdf5'
archivo_acc = './accuracy.png'
archivo_loss = './loss.png'
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTarea: ' + tarea
log += '\nModelo de red: Ventana'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nOptimizer: adam'
log += '\nActivacion: relu'
print 'Compilando red...'
# Defino las capas de la red
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
input_length=window_size, trainable=True)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=1),
input_length=window_size, trainable=True)
second_layer = Dense(units=unidades_ocultas_capa_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=2),
bias_initializer=Constant(value=0.1))
third_layer = Dense(units=unidades_ocultas_capa_3,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=3),
bias_initializer=Constant(value=0.1))
# Agrego las capas al modelo
model = Sequential()
model.add(embedding_layer)
model.add(Flatten())
model.add(second_layer)
model.add(Activation("relu"))
model.add(third_layer)
model.add(Activation("softmax"))
#.........这里部分代码省略.........
示例10: palabras_comunes
import sys
import tensorflow as tf
import csv
csv.field_size_limit(sys.maxsize)
window_size = 11 # Cantidad de palabras en cada caso de prueba
vector_size = 50 # Cantidad de features para cada palabra. Coincide con la cantidad de hidden units de la primer capa
cant_palabras = 16665 + 4 # Cantidad de palabras consideradas en el diccionario + 4 tags especiales
unidades_ocultas_capa_2 = 100
unidades_ocultas_capa_3 = 1
file_length = 10
batch_size = 25
# Obtenemos diccionario con las palabras a utilizar
p = palabras_comunes("lexicon/lexicon.txt")
def generar_vectores_iniciales(cantidad, tamano):
lista_vectores = []
for i in range (0, cantidad):
vector = []
for k in range(0, tamano):
vector.append(random())
lista_vectores.append(vector)
return lista_vectores
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
示例11: main
def main(tarea, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
archivo_corpus_pruebas = path_proyecto + '/corpus/Sentencia/Testing/' + tarea + '_testing.csv'
vector_size_distancia = 5 # Cantidad de features para representar la distancia a la palabra a etiquetar
largo_sentencias = 50
def cargarCasos(archivo, extra=False):
# Abro el archivo
x = []
y = []
with open(archivo, 'rb') as archivo_csv:
lector = csv.reader(archivo_csv, delimiter=',')
for linea in lector:
largo_x = largo_sentencias + 1
x.append([int(t) for t in linea[:largo_x]])
y.append([int(t) for t in linea[largo_x:]])
x_a = [l[1:] for l in x]
x_b = [ [largo_sentencias+i-l[0] for i in range(largo_sentencias)] for l in x] # Matriz que almacenara distancias a la palabra a analizar
x_a = np.array(x_a)
x_b = np.array(x_b)
x_c = [l[0] for l in x]
y = np.array(y)
return x_a, x_b, y, x_c
# Cargo casos
inicio_carga_casos = time.time()
print 'Cargando casos de prueba...'
x_test_a, x_test_b, y_test, x_c = cargarCasos(archivo_corpus_pruebas)
duracion_carga_casos = time.time() - inicio_carga_casos
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
unidades_ocultas_capa_2_2 = 500
unidades_ocultas_capa_3 = len(y_test[0])
archivo_best = 'mejores_pesos.hdf5'
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTESTING'
log += '\nTarea: ' + tarea
log += '\nModelo de red: Convolutiva'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nOptimizer: adam'
log += '\nActivacion: relu'
print 'Compilando red...'
# Defino las capas de la red
main_input = Input(shape=(largo_sentencias,), name='main_input')
aux_input_layer = Input(shape=(largo_sentencias,), name='aux_input')
distance_embedding_layer = Embedding(input_dim=largo_sentencias*2, output_dim=vector_size_distancia,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=4),
trainable=True)(aux_input_layer)
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
trainable=True)(main_input)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=1),
trainable=True)(main_input)
concat_layer = Concatenate()([embedding_layer, distance_embedding_layer])
convolutive_layer = Conv1D(filters=unidades_ocultas_capa_2, kernel_size=5)(concat_layer)
#.........这里部分代码省略.........
示例12: main
def main(supertag = 0, cant_iteraciones = 20, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
vector_size_distancia = 5 # Cantidad de features para representar la distancia a la palabra a etiquetar
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
unidades_ocultas_capa_2_2 = 500
# Defino las tareas a entrenar...
supertags= ['supertag_reducido_compactado', 'supertag_reducido', 'supertag_completo_compactado', 'supertag_completo']
nombre_tareas = ['microchunking', 'macrochunking', 'ner', 'pos', 'srl', supertags[supertag]]
tareas = []
inicio_carga_casos = time.time()
for t in nombre_tareas:
tareas.append(Tarea(t, cant_iteraciones))
duracion_carga_casos = time.time() - inicio_carga_casos
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTareas: ' + str(nombre_tareas)
log += '\nModelo de red: Convolutiva'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nActivacion: relu'
log += '\nOptimizador: adam'
print 'Compilando red...'
# Defino las capas de la red
main_input = Input(shape=(largo_sentencias,), name='main_input')
aux_input_layer = Input(shape=(largo_sentencias,), name='aux_input')
distance_embedding_layer = Embedding(input_dim=100, output_dim=vector_size_distancia,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=4),
trainable=True)(aux_input_layer)
aux_input_layer2 = Input(shape=(largo_sentencias,), name='aux_input2')
distance_embedding_layer2 = Embedding(input_dim=100, output_dim=vector_size_distancia,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=5),
trainable=True)(aux_input_layer2)
concat_layer_aux = Concatenate()([distance_embedding_layer, distance_embedding_layer2])
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
trainable=True)(main_input)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=1),
trainable=True)(main_input)
concat_layer = Concatenate()([embedding_layer, concat_layer_aux])
convolutive_layer = Conv1D(filters=unidades_ocultas_capa_2, kernel_size=5)(concat_layer)
x_layer = GlobalMaxPooling1D()(convolutive_layer)
second_layer = Dense(units=unidades_ocultas_capa_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=2),
bias_initializer=Constant(value=0.1))(x_layer)
y_layer = Activation("tanh")(second_layer)
inputs = [main_input, aux_input_layer, aux_input_layer2]
for t in tareas:
if t.srl:
second_layer_2 = Dense(units=unidades_ocultas_capa_2_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=6),
bias_initializer=Constant(value=0.1))(y_layer)
y_layer_2 = Activation("tanh")(second_layer_2)
#.........这里部分代码省略.........
示例13: main
def main(tarea, precalculado = False):
archivo_embedding = path_proyecto + "/embedding/embedding_ordenado.txt"
archivo_lexicon = path_proyecto + "/embedding/lexicon_total.txt"
archivo_corpus_pruebas = path_proyecto + '/corpus/Ventana/Testing/' + tarea + '_testing.csv'
def cargarCasos(archivo):
# Abro el archivo
df = pd.read_csv(archivo, sep=',', skipinitialspace=True, header=None, quoting=3)
largo = len(df)
# Separo features de resultados esperados
x = np.array(df.iloc[:largo,:11])
y = np.array(df.iloc[:largo,11:])
return x, y
# Cargo casos
inicio_carga_casos = time.time()
print 'Cargando casos de prueba...'
x_test, y_test = cargarCasos(archivo_corpus_pruebas)
duracion_carga_casos = time.time() - inicio_carga_casos
window_size = 11 # Cantidad de palabras en cada caso de prueba
vector_size = 150 if precalculado else 50 # Cantidad de features a considerar por palabra
unidades_ocultas_capa_2 = 300
unidades_ocultas_capa_3 = len(y_test[0])
archivo_best = 'mejores_pesos.hdf5'
log = 'Log de ejecucion:\n-----------------\n'
log += '\nTESTING'
log += '\nTarea: ' + tarea
log += '\nModelo de red: Ventana'
log += '\nEmbedding inicial: '
if precalculado:
log += 'Precalculado'
else:
log += 'Aleatorio'
log += '\nOptimizer: adam'
log += '\nActivacion: relu'
print 'Compilando red...'
# Defino las capas de la red
# Cargo embedding inicial
if precalculado:
embedding_inicial = []
for l in open(archivo_embedding):
embedding_inicial.append(list([float(x) for x in l.split()]))
embedding_inicial = np.array(embedding_inicial)
cant_palabras = len(embedding_inicial)
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size, weights=[embedding_inicial],
input_length=window_size, trainable=True)
else:
palabras = palabras_comunes(archivo_lexicon) # Indice de cada palabra en el diccionario
cant_palabras = len(palabras) # Cantidad de palabras consideradas en el diccionario
embedding_layer = Embedding(input_dim=cant_palabras, output_dim=vector_size,
embeddings_initializer=RandomUniform(minval=-0.05, maxval=0.05, seed=1),
input_length=window_size, trainable=True)
second_layer = Dense(units=unidades_ocultas_capa_2,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=2),
bias_initializer=Constant(value=0.1))
third_layer = Dense(units=unidades_ocultas_capa_3,
use_bias=True,
kernel_initializer=TruncatedNormal(mean=0.0, stddev=0.1, seed=3),
bias_initializer=Constant(value=0.1))
# Agrego las capas al modelo
model = Sequential()
model.add(embedding_layer)
model.add(Flatten())
model.add(second_layer)
model.add(Activation("relu"))
model.add(third_layer)
model.add(Activation("softmax"))
# Compilo la red
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.summary()
#.........这里部分代码省略.........