def store_selection():
configs = Configurations()
store = configs.first()
if len(configs) > 1:
selection = raw_input('Store ID: ')
store = int(selection) if selection else store
config = configs.to(store)
return store, config
def post(self):
"""SComparing similairty of faces in two different images."""
logging.info('Received post message.')
args = file_upload.parse_args()
# print(args)
if 'image' not in args['first_image'].content_type:
logging.error('First file is not an image')
return api.abort(
400, 'Expecting only image files. First File is not an image.')
if 'image' not in args['second_image'].content_type:
logging.error('Second file is not an image')
return api.abort(
400,
'Expecting only image files. Second file is not an image.')
filename1 = os.path.join(Configurations().image_upload_folder,
args['first_image'].filename)
filename2 = os.path.join(Configurations().image_upload_folder,
args['second_image'].filename)
logging.info('Saving image files.')
args['first_image'].save(filename1)
logging.info('Saved {}'.format(filename1))
args['second_image'].save(filename2)
logging.info('Saved {}'.format(filename2))
logging.info('Loading image files.')
first_image = face_recognition.load_image_file(filename1)
logging.info('Loaded first image.')
second_image = face_recognition.load_image_file(filename2)
logging.info('Loaded second image.')
# dets = detector(first_image, 1)
logging.info('Finding Facial encodings')
first_image_encoding = face_recognition.face_encodings(first_image)
second_image_encoding = face_recognition.face_encodings(second_image)
if len(first_image_encoding) == 0:
logging.error('Unable to detect face in the first image')
api.abort(500, 'Unable to detect face in the first image')
if len(second_image_encoding) == 0:
logging.error('Unable to detect face in the second image')
api.abort(500, 'Unable to detect face in the second image')
# comparision_result = face_recognition.compare_faces([first_image_encoding], second_image_encoding)
logging.info('Finding distance between faces.')
face_distance = np.linalg.norm(first_image_encoding[0] -
second_image_encoding[0])
logging.info('Face distance found as {}'.format(face_distance))
return {'similarity': 1 - face_distance}, 201
class Validator :
''' Clase que valida el estado de distintas partes del programa. '''
def __init__(self) :
self.pt = PathTools()
self.config = Configurations()
def checkFolders (self) :
""" Verifica que existan los directorios de la aplicación """
# obtiene la ruta del directorio /databases
databases_dir = self.pt.getPathDatabasesDir()
# si no existe el directorio, lo crea
if not os.path.exists(databases_dir) :
print 'El directorio /databases no existia, ha sido creado nuevamente.'
os.mkdir(databases_dir)
# obtiene la ruta del directorio /data
data_dir = self.pt.getPathDataDir()
# si no existe el directorio, lo crea
if not os.path.exists(data_dir) :
print 'El directorio /data no existia, ha sido creado nuevamente.'
os.mkdir(data_dir)
def checkExistCfg (self) :
""" Verifica la existencia del archivo de configuracion """
existe = False
path_cfg = self.pt.getPathCFGFile()
if not os.path.exists(path_cfg):
self.config.regenerateNewCFG()
existe = True
return existe
def checkIntegrityCfg (self) :
""" Verifica la integridad del archivo de configuracion """
pass
def check (self) :
# verifica la existencia de los directorios
self.checkFolders()
# verifica la existencia del archivo de configuracion
self.checkExistCfg()
def __init__(self):
# class instances
self._DBUtils = DBUtils()
self._PT = PathTools()
self._Configs = Configurations()
# private instances
self._BD = None
# diccionario con todas las instancia de objeto Snippet
self._Snippets = None
# objeto snippet mostrado actualmente en GUI
self._SnippetActual = None # Snippet
# esta variable, se utilizara para saber si la instancia de
# snippetmanager se creo correctamente con una bd determinada
# o se creo vacia, indicando que no se puede realizar ninguna
# operacion sobre la aplicacion
self._estado = False
# lista con las rutas de las base de datos
# tanto las del pathdefault como del cfg file
self._AllPathDBs = []
self.loadAllPathDBs()
# trae si existe, el valor de la bd a cargar por defecto
defaultBdName = self._Configs.defaultBdName
def main(_):
config = Configurations()
config.input_file_pattern = FLAGS.input_file_pattern
g = tf.Graph()
with g.as_default():
model = Model("train", config)
model.build()
train_op = model.train_op
tf.contrib.slim.learning.train(
model.train_op,
config.train_dir,
log_every_n_steps=FLAGS.log_every_n_steps,
graph=g,
global_step=model.global_step,
number_of_steps=FLAGS.number_of_steps,
saver=model.saver)
def main(_):
# Build the inference graph.
g = tf.Graph()
with g.as_default():
model = inference_wrapper.InferenceWrapper()
restore_fn = model.build_graph_from_config(Configurations(),
FLAGS.checkpoint_path)
g.finalize()
# Create the vocabulary.
vocab = vocabulary.Vocabulary(FLAGS.vocab_file)
filenames = []
for file_pattern in FLAGS.input_files.split(","):
filenames.extend(tf.gfile.Glob(file_pattern))
tf.logging.info("Running caption generation on %d files matching %s",
len(filenames), FLAGS.input_files)
with tf.Session(graph=g) as sess:
# Load the model from checkpoint.
restore_fn(sess)
# Prepare the caption generator. Here we are implicitly using the default
# beam search parameters. See caption_generator.py for a description of the
# available beam search parameters.
generator = caption_generator.CaptionGenerator(model, vocab)
for filename in filenames:
with tf.gfile.GFile(filename, "r") as f:
image = f.read()
captions = generator.beam_search(sess, image)
print("Captions for image %s:" % os.path.basename(filename))
for i, caption in enumerate(captions):
# Ignore begin and end words.
sentence = [
vocab.id_to_word(w) for w in caption.sentence[1:-1]
]
sentence = " ".join(sentence)
print(" %d) %s (p=%f)" %
(i, sentence, math.exp(caption.logprob)))
def __init__(self):
self.pt = PathTools()
self.config = Configurations()
class SnippetManagerBase:
''' Clase que hace de wrapper entre las clases
de la logica del programa, con la clase Fragmentos'''
def __init__(self):
# class instances
self._DBUtils = DBUtils()
self._PT = PathTools()
self._Configs = Configurations()
# private instances
self._BD = None
# diccionario con todas las instancia de objeto Snippet
self._Snippets = None
# objeto snippet mostrado actualmente en GUI
self._SnippetActual = None # Snippet
# esta variable, se utilizara para saber si la instancia de
# snippetmanager se creo correctamente con una bd determinada
# o se creo vacia, indicando que no se puede realizar ninguna
# operacion sobre la aplicacion
self._estado = False
# lista con las rutas de las base de datos
# tanto las del pathdefault como del cfg file
self._AllPathDBs = []
self.loadAllPathDBs()
# trae si existe, el valor de la bd a cargar por defecto
defaultBdName = self._Configs.defaultBdName
##########################
## Metodos de instancia ##
##########################
def agregarSnippet(self, datosSnippet):
''' Recibe un dicionario de los datos de lo que sera un nuevo
snippet y lo agrega a la BD.'''
# llama al metodo de bd para agregar un snippet, devolviendo
# el resultado de la operacion como boolean y en caso de error,
# el mensaje del error.
resultado, mensaje = self._BD.agregarSnippet(datosSnippet)
if resultado:
# crea una instancia del nuevo snippet
newSnippet = Snippet(datosSnippet, self._BD)
# agrega el nuevo snippet a los ya existentes
self._addNewSnippetToCollection(newSnippet)
# retorna que la operacion fue exitosa,
# y ningun mensaje de error
return True, None
else:
# retorna que la operacion no fue exitosa, y
# el mensaje de error devuelto por bd
return False,mensaje
def eliminarSnippet(self, unSnippet):
''' Manda a eliminarSnippet de la Bd que
borre el snippet segun su titulo y lenguaje.'''
# llama al metodo de bd para eliminar un snippet
# y devuelve un booleano con el resultado de la operacion.
if self._BD.eliminarSnippet(
unSnippet.titulo, unSnippet.lenguaje):
# quita del diccionario el snippet
self._Snippets.pop((unSnippet.lenguaje,
unSnippet.titulo))
# establece como actual snippet a None
self._SnippetActual = None
return True
else:
return False
def modificarSnippet(self, clave_spviejo, snippet_nuevo):
''' Actualiza el snippet cargado en memoria'''
del self._Snippets[clave_spviejo]
self._Snippets[
(snippet_nuevo.lenguaje,snippet_nuevo.titulo)
] = snippet_nuevo
def newSnippet(self, tuplaSnippet):
''' Crea una instancia de snippet. '''
# a partir de los valores que vienen en la tupla,
# se crea una instancia de snippet con dichos valores.
nuevoSnippet = Snippet({
'title':tuplaSnippet[0],
'language':tuplaSnippet[1],
'tags':tuplaSnippet[2],
'contens':tuplaSnippet[3],
'description':tuplaSnippet[4],
'creation':tuplaSnippet[5],
'reference':tuplaSnippet[6],
'modified':tuplaSnippet[7],
'uploader':tuplaSnippet[8],
'starred':tuplaSnippet[9]},
self._BD)
# tupla que sera de clave en el diccionario de los snippets
clave = (tuplaSnippet[1],tuplaSnippet[0])
elemento_diccionario = (clave,nuevoSnippet)
return elemento_diccionario
def _addNewSnippetToCollection(self, newSnippet):
''' Agrega el nuevo snippet creado a la coleccion actual de snippets. '''
self._Snippets.update(
{(newSnippet.lenguaje, newSnippet.titulo):newSnippet})
#################
## Metodos Get ##
#################
def getAllLenguajes(self):
''' Obtiene una lista de los lenguajes desde la bd.'''
# obtiene desde la actual instancia de bd los lenguajes existentes
all_lenguajes = self._BD.getLenguajes()
lenguajes = []
# saca de la tupla y carga en la lista los lenguajes obtenidos
#~ for lenguaje in all_lenguajes:
#~ lenguajes.append(lenguaje[0])
map(lambda lenguaje: lenguajes.append(lenguaje[0]), all_lenguajes)
return lenguajes
def getBDNames(self):
''' Obtiene una lista con los nombres de los archivos bds.'''
databases_dir = self._DBUtils.getBDsNamesDatabasesDir()
cfg_file = self._Configs.getDBsNamesCFGReferences()
couch_dbs = [name + ' [CouchDB]'for name in self._Configs.getNamesCouch()]
return databases_dir + cfg_file + couch_dbs
def getDB(self):
return self._BD
def getAllSnippets(self):
''' Obtiene los snippets desde la bd y carga en un diccionario
los snippets en formato objeto Snippet().'''
# obtiene desde la bd todos los snippets,
# orden en que vienen los campos
# 1-title,2-language,3-tags,4-contens,5-description
# 6-creation,7-reference,8-modified,9-uploader,10-starred
all_snippets = self._BD.getAllSnippets()
# se aplica map para crear por cada tupla obtenida desde la bd
# una tupla de tuplas donde el formato resultante es:
# (claveSnippet : instanciaSnippet)
todos_los_snippets = map(self.newSnippet,all_snippets)
# dict(), convierte la tupla de tuplas a diccionario
return dict(todos_los_snippets)
def getInstanceState(self):
''' '''
return self._estado
def getIndexBdName(self, bdName):
''' Busca en la lista de bds la ocurrencia de la primer bd que
coincida con el nombre del parametro <bdName>, devolviendo la
posicion en que se encuentra.
Devuelve -1 si no se encuentra. '''
return self._AllPathDBs.index(bdName)
def getLengsAndTitles(self,consulta=None, favorito = None):
''' Obtiene los snippets por lenguajes desde la bd.'''
#~ tagsPresicion = bool(self._DBUtils.configs.searchPresitionTags)
tagsPresicion = False
return self._BD.getLengAndTitles(consulta, favorito, tagsPresicion)
def getSnippet(self, lenguaje, titulo):
''' Obtiene un snippet por su lenguaje y titulo correspondiente. '''
try:
# del diccionario donde estan todas las instancias de snippet,
# a partir de la clave tupla, recupera la instancia
# con lenguaje y titulo indicado
snippet = self._Snippets[(lenguaje,titulo)]
# establece como instancia actual en uso, la instancia obtenida
self.setSnippetActual(snippet)
except Exception, msg:
# si el snippet no esta en el diccionario, devuelve None
snippet = None
self.setSnippetActual(snippet)
print 'getSnippet Error: ',msg
return snippet
invalid_params.append('config_template')
if len(invalid_params) > 0:
show_invalid_params(invalid_params, parsed_params)
show_help(program_name, parsed_params)
sys.exit(1)
return parsed_params
def create_logs_path():
logpath = os.path.join(BASE_DIR, 'logs')
if not os.path.exists(logpath):
log.info("Key directory doesn't exist. Making the directory ...")
try:
os.mkdir(logpath)
except Exception as e:
log.error('Error: Failed to create dir {}'.format(logpath))
log.error('Exception occured', exc_info=True)
sys.exit(1)
if __name__ == "__main__":
create_logs_path()
parsed_params = parse_cmd_parameters()
config = Configurations(parsed_params)
manager = Manager(config)
manager.start()
optimizer.apply_gradients(grads_and_vars=zip(
grads, model.variables)) # 更新参数
if (batch + 1) % 50 == 0:
print('[Epoch{} Batch{}] loss:{:.3f}'.format(
epoch + 1, batch + 1, loss.numpy()))
manager.save() # 每个epoch后保存一个checkpoint
print('Epoch{} Loss: {:.5f}'.format(epoch + 1, np.mean(epoch_loss)))
print('***************')
if __name__ == '__main__':
train_X = np.loadtxt('/data/train_X.txt', dtype='int')
train_Y = np.loadtxt('/data/train_Y.txt', dtype='int')
test_X = np.loadtxt('/data/test_X.txt', dtype='int')
index2word, word2index, embedding_matrix = load_vocab_embedding_matrix()
config = Configurations()
train_dataset = tf.data.Dataset.from_tensor_slices(
(train_X, train_Y)).batch(config.batch_size)
model = Seq2seq(vocab_size=embedding_matrix.shape[0],
embedding_dim=embedding_matrix.shape[1],
embedding_matrix=embedding_matrix,
gru_units=config.hid_dim,
dropout_rate=config.dropout)
training(model, train_dataset, config.epochs, config.learning_rate,
word2index['<PAD>'])
"""Snake game in python"""
from pathlib import Path
import pygame
from direction import Direction
from game import Game
from configurations import Configurations
pygame.init()
pygame.display.set_caption("PySnake")
ABS_PATH = str(Path(r"images\png-snake-icon.png").absolute())
icon = pygame.image.load(ABS_PATH)
pygame.display.set_icon(icon)
clock = pygame.time.Clock()
cf = Configurations()
game = Game(cf)
win = pygame.display.set_mode(
(cf.board_width + 1, cf.board_width + 1 + cf.cell_size * 2))
# Main game loop
while True:
pygame.time.delay(260 - game.level * 20)
clock.tick(40)
for event in pygame.event.get():
if event.type == pygame.QUIT:
game.quit_game()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
game.snake.set_direction(Direction.RIGHT)