def __init__(self, initial_population, generations):
"""
A genetic algorithm is used to learn the weights and bias of a topology
fixed network.
"""
super().__init__(initial_population)
#self.expected_precision = expected_precision
self.generation_span = generations
self.precision = 0
self.epoch = 0
self.num_inputs = 4
self.neurons_per_layer = [self.num_inputs, 4, 3]
# Build Fixed Neural Network, with 4 inputs
self.neural_network = NeuralNetwork(self.num_inputs)
# The neural network has 3 layers with 3,4 and 3 neurons in each
self.neural_network.buildFixed(self.neurons_per_layer)
self.test_values = 20
# Parse data set
file_manager = FileManager()
file_manager.load_file("../Datasets/iris.data")
self.train_data = file_manager.get_train_data()
self.test_data = file_manager.get_test_data()
self.neurons_position = []
self.x_plot = []
self.y_plot = []
def test_file_manager(self):
file_manager = FileManager()
file_manager.load_file("../Datasets/test.data")
normalize_data_1 = [[2.0, 2.0, 2.0, 2.0, [0, 1, 0]]]
normalize_data_2 = [[1.0, 1.0, 1.0, 1.0, [1, 0, 0]]]
self.assertEqual(file_manager.get_train_data(), normalize_data_1)
self.assertEqual(file_manager.get_test_data(), normalize_data_2)
def main():
"""
@return:
"""
sprint = AsanaWrapper(os.getenv("ASANA_KEY"))
pld_json = sprint.get_sprint_tasks([os.getenv("TASK")])
gen = DiagramGenerator()
dump(pld_json)
gen.create_xml_tree("Terradia", pld_json)
FileManager().generate_svg_from_xml()
return 0
def __init__(self):
"""
init the creation date used as suffix for the filename
init the FileManager used for reading the template and generate tge xml
init the template engine
"""
self.gen_date = "_" + str(datetime.now().month) + "_" + str(
datetime.now().year)
self.fm = FileManager()
self.template = Template(
self.fm.io("UserStorieTemplate",
path="../assets/",
extension=".xml"))
def main():
# Parse data set
file_manager = FileManager()
file_manager.load_file("../Datasets/iris.data")
train_data = file_manager.get_train_data()
test_data = file_manager.get_test_data()
number_of_epochs = 2000
# Training data can be shuffled
# shuffle(train_data)
"""
Genetic Algorithm (Tarea 3)
"""
# -------------------------------------------------
genetic = GeneticFixedTopology(100, 1000)
best_neural_network = genetic.run()
genetic.plot_results()
def test1():
fm = FileManager()
# data = fm.read_input("c_memorable_moments.txt")
data = fm.read_input("b_lovely_landscapes.txt")
minH = 999999999999
minV = 999999999999
maxV = -1
maxH = -1
for image in data['images']:
if image['type'] == 'V':
minV = min(minV, len(image['tags']))
maxV = max(maxV, len(image['tags']))
else:
minH = min(minH, len(image['tags']))
maxH = max(maxH, len(image['tags']))
print(minH)
print(minV)
print(maxH)
print(maxV)
def main(args):
## deve ler as informações do arquivo
fm = FileManager(args.arquivo)
rs = RecommenderSystem(fm)
## - O número de itens avaliados pelo Usuário X
print( rs.getUser(args.usuario).getReviewsLength() )
## - O número de usuários que avaliaram o Item Y
print( rs.getItem(args.item).getReviewsLength() )
## - Se o Usuário X avaliou o Item Y
## r<sub>x,y</sub>
if rs.hasRating(args.usuario, args.item):
print( rs.getRating(args.usuario, args.item) )
## - Se o Usuário X não avaliou o Item Y
## pred(r<sub>x,y</sub>) usando abordagem baseada em usuários (Seção 2.1.1)
## pred(r<sub>x,y</sub>) usando abordagem baseada em itens (Seção 2.2.1)
else:
print( rs.getUserBasedPrediction(args.usuario, args.item) )
print( rs.getItemBasedPrediction(args.usuario, args.item) )
def build(self):
self.__createFile()
return FileManager(self.filename)
def read_csv(filename, header=0, sep=';'):
fileManager = FileManager(filename, header, sep)
return pdFakeFile(fileManager)
if __name__ == "__main__":
# Argparse
parser = argparse.ArgumentParser()
parser.add_argument("--report", action="store_true")
args = parser.parse_args()
report = args.report
# Env file
load_dotenv()
db_user = os.getenv("POSTGRES_USER", os.getenv("DB_USER"))
db_pwd = os.getenv("POSTGRES_PASSWORD", os.getenv("DB_PWD"))
db_name = os.getenv("POSTGRES_DB", os.getenv("DB_NAME"))
provider = os.getenv("PROVIDER", "postgresql")
port = os.getenv("port", "5432")
# Cleaning & inserting
fm = FileManager(db_user, db_pwd, db_name, provider, port)
users = fm.clean_users()
ads = fm.clean_ads()
referrals = fm.clean_referrals()
ads_transaction = fm.clean_ads_transaction()
# Report
if report:
rm = ReportManager(users=users,
ads=ads,
referrals=referrals,
ads_transaction=ads_transaction)
rm.process()
import sys
import tkinter as tk
from typing import List
from src.load import config
from src.FileManager import FileManager
from src.StateManager import StateManager
if __name__ == '__main__':
filename = sys.argv[1]
fm = FileManager(filename, config['rows'], config['columns'])
fm.read()
if (fm.is_data_corrupt()):
decision = input('data file is corrupt, fix it automatically? (y/n): ')
if (decision == 'y' or decision == 'Y'):
fm.fix_data()
else:
sys.exit()
fm.write()
app = tk.Tk()
sm = StateManager(fm.data, fm.rows, fm.columns,
config['pixel_on_hex_color'],
config['pixel_off_hex_color'])
header_section0 = tk.Frame(app)
tk.Button(header_section0,
text='Save',
command=fm.write,
highlightbackground=config['save_button_color']).pack()
header_section0.pack()
def test2():
fm = FileManager()
data = fm.read_input("c_memorable_moments.txt")
# data = fm.read_input("b_lovely_landscapes.txt")
foo = SlideShower(data)
foo.main()
def __init__(self):
self.gen_date = "_" + str(datetime.now().month) + "_" + str(
datetime.now().year)
self.UserStorie = UserStories()
self.fm = FileManager()
