def execute(input_file, solution_file, permutations_count, iterations, distance_factor): input_reader = InputFileReader(input_file) dimension, weights, distances = input_reader.read() distance = dimension * distance_factor qap = QAP(weights, distances) optimal_value = None optimal_permutation = None if solution_file is not None: solution_reader = SolutionFileReader(solution_file) solution_dimension, solution_value, solution_permutation = solution_reader.read( ) if solution_dimension != dimension: raise RuntimeError( "Solution dimension is different than input dimension") if qap.get_value(solution_permutation) != solution_value: raise RuntimeError( "Solution value does not match calculated solution permutation value" ) optimal_value = solution_value optimal_permutation = solution_permutation permutations = generate_permutations(permutations_count, dimension) start_time = time.time() for iteration in range(iterations): best_permutation, best_permutation_index, best_value = find_best_permutation( permutations, qap) next_permutations = [] for i in range(len(permutations)): if i == best_permutation_index: next_permutations.append(permutations[i]) continue else: surroundings = get_surroundings(i, permutations, distance) new_permutation = attraction_injection(permutations[i], surroundings, qap) next_permutations.append(new_permutation) permutations = next_permutations end_time = time.time() values = [qap.get_value(p) for p in permutations] best = min(values) diff = (best - optimal_value) / best * 100 return best, round(diff, 2), round(end_time - start_time, 2)
def attraction_injection(permutation, surroundings, qap: QAP): result = permutation.copy() permutation_value = qap.get_value(permutation) dimension = len(permutation) for p in surroundings: if permutation_value >= qap.get_value(p): lower, upper = get_random_range(dimension - 1) result = pmx(p, result, lower, upper) else: result = repulsion(p, result) return result
def find_best_permutation(permutations, qap: QAP): best_permutation = permutations[0] best_permutation_index = 0 best_value = qap.get_value(best_permutation) for i in range(len(permutations)): new_value = qap.get_value(permutations[i]) if new_value < best_value: best_value = new_value best_permutation = permutations[i] best_permutation_index = i return best_permutation.copy(), best_permutation_index, best_value
from arguments import parse_arguments from qap.input_file_reader import InputFileReader from qap.solution_file_reader import SolutionFileReader from qap.qap import QAP from em_discrete.em_discrete import generate_permutations from em_discrete.em_discrete_cuda import em_discrete from plot import plot_results if __name__ == '__main__': input_file, solution_file, permutations_count, iterations, hamming_distance = parse_arguments( sys.argv[1:]) input_reader = InputFileReader(input_file) dimension, weights, distances = input_reader.read() qap = QAP(weights, distances) optimal_value = None optimal_permutation = None if solution_file is not None: solution_reader = SolutionFileReader(solution_file) solution_dimension, solution_value, solution_permutation = solution_reader.read( ) if solution_dimension != dimension: raise RuntimeError( "Solution dimension is different than input dimension") if qap.get_value(solution_permutation) != solution_value: raise RuntimeError(
import numpy as np from numba import cuda from em_qap_gpu import calculate_forces, find_best_point, calculate_charges, qap_host from qap.input_file_reader import InputFileReader from em_cpu.em_solver import EMSolver from qap.qap import QAP from tests.test_points import test_points if __name__ == '__main__': """ Checks if forces calculated by cpu and gpu versions are same """ reader = InputFileReader("../../test_instances/Chr/chr20a.dat") dimension, weights, distances = reader.read() qap = QAP(weights, distances) qap_function = qap.get_em_function() solver = EMSolver(10, 20, [0] * 20, [10] * 20, qap_function) solver._EMSolver__points = np.array(test_points) calculated_forces = solver._EMSolver__calculate_forces() charges = np.zeros((len(test_points), 1)) forces = np.zeros((len(test_points), 20)) device_points = cuda.to_device(test_points) device_weights = cuda.to_device(weights) device_distances = cuda.to_device(distances) device_charges = cuda.to_device(charges) device_forces = cuda.to_device(forces)
def execute(input_file, solution_file, permutations_count, iterations, hamming_distance_factor): #input_file, solution_file, permutations_count, iterations, hamming_distance = parse_arguments(sys.argv[1:]) input_reader = InputFileReader(input_file) dimension, weights, distances = input_reader.read() hamming_distance = int(dimension * hamming_distance_factor) qap = QAP(weights, distances) optimal_value = None optimal_permutation = None if solution_file is not None: solution_reader = SolutionFileReader(solution_file) solution_dimension, solution_value, solution_permutation = solution_reader.read( ) if solution_dimension != dimension: raise RuntimeError( "Solution dimension is different than input dimension") if qap.get_value(solution_permutation) != solution_value: raise RuntimeError( "Solution value does not match calculated solution permutation value" ) optimal_value = solution_value optimal_permutation = solution_permutation permutations = generate_permutations(permutations_count, dimension) values = [0] * permutations_count start_time1 = time.time() previous_permutations = cuda.to_device(permutations) next_permutations = cuda.to_device(permutations) pmx_buffer = cuda.to_device(permutations) device_values = cuda.to_device(values) device_weights = cuda.to_device(weights) device_distances = cuda.to_device(distances) threads_per_block = permutations_count blocks = 1 random_states = create_xoroshiro128p_states(threads_per_block * blocks, seed=time.time()) start_time2 = time.time() for _ in range(iterations): em_discrete[blocks, threads_per_block](previous_permutations, next_permutations, device_values, device_weights, device_distances, hamming_distance, random_states, pmx_buffer) tmp = previous_permutations previous_permutations = next_permutations next_permutations = tmp end_time2 = time.time() host_values = device_values.copy_to_host() end_time1 = time.time() best = min(host_values) diff = (best - optimal_value) / best * 100 return best, round(diff, 2), round(end_time2 - start_time2, 2), round(end_time1 - start_time1, 2)
def solve(input_file, solution_file, points_count, iterations, upper_bound, lower_bound): input_reader = InputFileReader(input_file) dimension, weights, distances = input_reader.read() optimal_value = None optimal_permutation = None if solution_file is not None: solution_reader = SolutionFileReader(solution_file) solution_dimension, solution_value, solution_permutation = solution_reader.read( ) qap = QAP(weights, distances) if solution_dimension != dimension: raise RuntimeError( "Solution dimension is different than input dimension") if qap.get_value(solution_permutation) != solution_value: raise RuntimeError( "Solution value does not match calculated solution permutation value" ) optimal_value = solution_value optimal_permutation = solution_permutation random.seed(time.time()) start_points = initialize(points_count, dimension, lower_bound, upper_bound) charges = np.zeros((points_count, 1)) forces = np.zeros((points_count, dimension)) start1 = time.time() device_points = cuda.to_device(start_points) device_weights = cuda.to_device(weights) device_distances = cuda.to_device(distances) device_charges = cuda.to_device(charges) device_forces = cuda.to_device(forces) # TODO: add check if points_count is lower than max threads per block threads_per_block = points_count blocks = 1 random_states = create_xoroshiro128p_states(threads_per_block * blocks, seed=time.time()) start2 = time.time() for it in range(iterations): local_search[blocks, threads_per_block](device_points, device_weights, device_distances, upper_bound, lower_bound, random_states) points = device_points.copy_to_host() best_point, best_value, best_index = find_best_point( points, weights, distances) denominator = sum([ qap_host(point, weights, distances) - best_value for point in points ]) calculate_charges[blocks, threads_per_block](device_points, device_weights, device_distances, best_value, denominator, device_charges) calculate_forces[blocks, threads_per_block](device_points, device_weights, device_distances, best_index, device_charges, device_forces) move[blocks, threads_per_block](device_points, best_index, device_forces, random_states) end2 = time.time() end1 = time.time() points = device_points.copy_to_host() best_point, best_value, best_index = find_best_point( points, weights, distances) diff = (best_value - optimal_value) / best_value * 100 return best_value, round(diff, 2), round(end2 - start2, 2), round(end1 - start1, 2)
from tqdm import tqdm from qap.input_file_reader import InputFileReader from qap.solution_file_reader import SolutionFileReader from qap.qap import QAP from em_discrete.arguments import parse_arguments from em_discrete.em_discrete import generate_permutations, find_best_permutation, get_surroundings, attraction_injection from em_qap_plot import plot_results if __name__ == '__main__': input_file, solution_file, permutations_count, iterations, distance = parse_arguments( sys.argv[1:]) input_reader = InputFileReader(input_file) dimension, weights, distances = input_reader.read() qap = QAP(weights, distances) optimal_value = None optimal_permutation = None if solution_file is not None: solution_reader = SolutionFileReader(solution_file) solution_dimension, solution_value, solution_permutation = solution_reader.read( ) if solution_dimension != dimension: raise RuntimeError( "Solution dimension is different than input dimension") if qap.get_value(solution_permutation) != solution_value: raise RuntimeError(