pikaia 0.0.2__tar.gz

pikaia-0.0.2/.gitignore

@@ -0,0 +1,42 @@
+# pycache
+__pycache__
+
+# ignore ALL .log files
+## Core latex/pdflatex auxiliary files:
+*.aux
+*.lof
+*.log
+*.lot
+*.fls
+*.out
+*.toc
+*.fmt
+*.fot
+*.cb
+*.cb2
+.*.lb
+
+## Bibliography auxiliary files (bibtex/biblatex/biber):
+*.bbl
+*.bbl-SAVE-ERROR
+*.bcf
+*.blg
+*-blx.aux
+*-blx.bib
+*.run.xml
+
+*.zip
+
+src/public/*.pdf
+src/public/*.png
+src/public/test
+src/public/venv
+src/public/dist
+src/public/__pycache__/
+src/public/geneticai/__pycache__/
+tmp/
+tutorial_env/
+venv/
+tex/*.pdf
+tex/*.png
+dist/

pikaia-0.0.2/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pikaia-0.0.2/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.3
+Name: pikaia
+Version: 0.0.2
+Summary: Data analysis with evolutionary simulation
+Project-URL: Homepage, https://github.com/danube-ai/pikaia
+Project-URL: Issues, https://github.com/danube-ai/pikaia/issues
+Author-email: Philipp Wissgott <philipp@danube.ai>, Andreas Roschal <andreas@danube.ai>, Martin Bär <martin@danube.ai>
+License: MIT
+Keywords: AI,data analysis,evolutionary simulation
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: matplotlib>=3.6.3
+Requires-Dist: numpy
+Requires-Dist: pandas>=1.5.3
+Requires-Dist: string
+Description-Content-Type: text/markdown
+
+# pikaia - Genetic AI
+
+pikaia is the Python implementation of Genetic AI (evolutionary simulation for data analysis).
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install pikaia 
+
+```bash
+pip install pikaia
+```
+
+## Usage 
+
+We provide here the code for the "hello_model" example
+
+```python
+import pikaia
+
+import pikaia
+import pikaia.alg
+          
+
+rawdata = np.zeros([3,3])
+rawdata[:,:] = [[ 300, 10, 2],
+                [ 600,  5, 2],
+                [1500,  4, 1]]
+# defines the variant fitness rules
+gvfitnessrules = ["inv_percentage", "inv_percentage", "inv_percentage"]
+# converts the raw data to a genetic population
+data = pikaia.alg.Population(rawdata, gvfitnessrules)
+# defines the used evolutionary strategies
+strategy = ["GS Dominant", "OS Balanced"]
+iterations = 1
+
+# creating the genetic model
+model = pikaia.alg.Model(data, strategy)
+
+initialgenefitness = [1.0/3.0, 1.0/3.0, 1.0/3.0]
+# returns the gene fitness values after 1 iteration
+model.complete_run(initialgenefitness, iterations)
+
+```
+
+## Examples
+```python
+# provides the data for a small decision problem
+example3x3 = pikaia.examples.assemble_example("3x3-DomBal+AltSal")
+
+# provides the data for a real-world decision problem
+example10x5 = pikaia.examples.assemble_example("10x5-DomBal+AltSal")
+
+# use genetic ai to search a datafile using keywords and rank results
+# for a more detailed example we refer to examples/geneticAI_run_search_example.py
+search = pikaia.search.Search(data, orgs_labels, gens_labels)
+fitnessOrganisms, fitnessGenes = search.search_request(query, top_k=5)
+```
+
+For details see examples/README.md.
+
+## Scientific Background
+
+Please find the preprint of Genetic AI [here](http://arxiv.org/abs/2501.19113)
+
+
+In Genetic AI, we convert a data problem to a model of genes and organisms. Afterwards, we run evolutionary simulations to obtain understanding of the input data.
+
+Genetic AI is an AI that does not use training data to 'learn' but fully autonomously analyzes a problem. This is done by evolutionary strategies that cover certain 'behavior' and correlations of the input data.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

pikaia-0.0.2/README.md

@@ -0,0 +1,72 @@
+# pikaia - Genetic AI
+
+pikaia is the Python implementation of Genetic AI (evolutionary simulation for data analysis).
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install pikaia 
+
+```bash
+pip install pikaia
+```
+
+## Usage 
+
+We provide here the code for the "hello_model" example
+
+```python
+import pikaia
+
+import pikaia
+import pikaia.alg
+          
+
+rawdata = np.zeros([3,3])
+rawdata[:,:] = [[ 300, 10, 2],
+                [ 600,  5, 2],
+                [1500,  4, 1]]
+# defines the variant fitness rules
+gvfitnessrules = ["inv_percentage", "inv_percentage", "inv_percentage"]
+# converts the raw data to a genetic population
+data = pikaia.alg.Population(rawdata, gvfitnessrules)
+# defines the used evolutionary strategies
+strategy = ["GS Dominant", "OS Balanced"]
+iterations = 1
+
+# creating the genetic model
+model = pikaia.alg.Model(data, strategy)
+
+initialgenefitness = [1.0/3.0, 1.0/3.0, 1.0/3.0]
+# returns the gene fitness values after 1 iteration
+model.complete_run(initialgenefitness, iterations)
+
+```
+
+## Examples
+```python
+# provides the data for a small decision problem
+example3x3 = pikaia.examples.assemble_example("3x3-DomBal+AltSal")
+
+# provides the data for a real-world decision problem
+example10x5 = pikaia.examples.assemble_example("10x5-DomBal+AltSal")
+
+# use genetic ai to search a datafile using keywords and rank results
+# for a more detailed example we refer to examples/geneticAI_run_search_example.py
+search = pikaia.search.Search(data, orgs_labels, gens_labels)
+fitnessOrganisms, fitnessGenes = search.search_request(query, top_k=5)
+```
+
+For details see examples/README.md.
+
+## Scientific Background
+
+Please find the preprint of Genetic AI [here](http://arxiv.org/abs/2501.19113)
+
+
+In Genetic AI, we convert a data problem to a model of genes and organisms. Afterwards, we run evolutionary simulations to obtain understanding of the input data.
+
+Genetic AI is an AI that does not use training data to 'learn' but fully autonomously analyzes a problem. This is done by evolutionary strategies that cover certain 'behavior' and correlations of the input data.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

pikaia-0.0.2/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling==1.26.3"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pikaia"
+version = "0.0.2"
+authors = [
+  { name="Philipp Wissgott", email="philipp@danube.ai" },
+  { name="Andreas Roschal", email="andreas@danube.ai" },
+  { name="Martin Bär", email="martin@danube.ai" }
+]
+description = "Data analysis with evolutionary simulation"
+keywords = ["data analysis", "AI", "evolutionary simulation"]
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+  "numpy",
+  "matplotlib>=3.6.3",
+  "string",
+  "pandas>=1.5.3"
+]
+
+[tool.hatch.build.targets.sdist]
+include = ["*.py"]
+exclude = ["tmp", "examples"]
+
+[project.urls]
+Homepage = "https://github.com/danube-ai/pikaia"
+Issues = "https://github.com/danube-ai/pikaia/issues"

pikaia-0.0.2/src/pikaia/alg.py

@@ -0,0 +1,437 @@
+import numpy as np
+
+class Model:
+    def __init__(self, inputdata, strategies, 
+                 genelabels=None, orgslabels=None,
+                 linestyles=None, markerstyles=None):
+        self._data = inputdata
+        self._strategies = strategies
+        self._genelabels = genelabels
+        self._orgslabels = orgslabels
+        self._linestyles = linestyles
+        self._markerstyles = markerstyles
+
+    @property
+    def data(self):
+        return self._data
+        
+
+    def complete_run(self, initialgenefitness, maxiteration=1, epsilon=None, silent=False):
+        """Runs an evolutionary simulation.
+
+        Runs a evolutionary simulation until either maxiter 
+        is reached or the difference of gene fitness values
+        from two consecutive iterations are below epsilon.
+
+        Args:
+            initialgenefitness (vector of shape `(1, m)`):
+                The initial fitness used in this simulation.
+        
+        Returns:
+            the similarity matrix `(n, n)`,
+        """
+        self._maxiter = maxiteration
+        self._epsilon = epsilon
+        genefitness = initialgenefitness
+        print("initial gene fitness = ", genefitness)
+        initialorganismfitness = compute_all_organism_fitness(self.data.population, genefitness)
+        if not silent:
+            print("initial organism fitness = ", initialorganismfitness)
+        
+        #iter = self._maxiter
+        n = self.data.population.shape[0]
+        m = self.data.population.shape[1]
+        # helper structures storing iterations
+        self._gps = np.zeros([self._maxiter+1, m])
+        self._ofs = np.zeros([self._maxiter+1, n])
+        self._gps[0,:] = genefitness
+        self._ofs[0,:] = initialorganismfitness
+
+        # compute similarities necessary for some strategies
+        genesimilarity = compute_gene_similarity(self.data.population)
+        orgsimilarity = compute_organism_similarity(self.data.population)
+        
+        for k in range(0, self._maxiter):
+            if not silent:
+                print("+++ Iteration ", k," +++")
+            genefitness, fitness = iteration(self.data.population, genefitness,
+                                            genesimilarity, orgsimilarity,
+                                            self._strategies, silent=silent)
+            self._gps[k+1,:] = genefitness
+            self._ofs[k+1,:] = fitness
+            if not silent:
+                print("gene fitness = ", genefitness)
+                print("organism fitness = ", fitness)
+            delta = np.linalg.norm(self._gps[k+1,:]-self._gps[k,:])
+            self._iterESE = k + 1
+            if self._epsilon is not None and delta < self._epsilon:
+                print("reached ESE after ", self._iterESE, "iterations. Final delta = ", delta)
+                break
+        return genefitness, fitness
+
+class Population:
+    def __init__(self, rawdata, gvfitnessrule):
+        self._rawdata = rawdata
+        self._n = self._rawdata.shape[0] #number of organisms
+        self._m = self._rawdata.shape[1] #number of genes
+        self._gvfitnessrules = gvfitnessrule
+        self._population = np.zeros([self._n,self._m]) 
+        for j in range(0, self._m):
+            # the populations derive from the raw data by applying gene variant 
+            # fitness functions
+            self._population[:,j] = compute_gene_variant_fitness(self._rawdata[:,j], 
+                                                                 self._gvfitnessrules[j])
+        print("Population = ", self._population)
+
+    @property
+    def n(self):
+        return self._n
+
+    @property
+    def m(self):
+        return self._m
+
+    @property
+    def rawdata(self):
+        return self._rawdata
+    
+    @property
+    def population(self):
+        return self._population
+    
+    def get_uniform_gene_fitness(self):
+        genefitness = np.zeros([self._m])
+        for j in range(0, self._m):
+            genefitness[j] = 1.0/self._m
+        return genefitness
+       
+
+def compute_gene_variant_fitness(genedata, gvfrule):
+    """Computes the gene variant fitness from raw data.
+
+    Args:
+        genedata (vector of shape `(n, 1)`):
+            The input data.
+        gvrule:
+            The gene variant fitness function applied.
+
+    Returns:
+        A float, the gene variant fitness.
+    """
+    if "inv" in gvfrule:
+        invert = True
+    else:
+        invert = False
+    
+    if "cap" in gvfrule:
+        cap = True
+    else:
+        cap = False
+    n = len(genedata)
+    maxvariant = max(genedata)
+    minvariant = min(genedata)
+    gvfitness = np.zeros(n)
+    for i in range(0, n):
+        if invert:
+            if cap:
+                gvfitness[i] = (maxvariant - genedata[i])/(maxvariant-minvariant) if (maxvariant-minvariant) != 0 else 0
+            else:
+                gvfitness[i] = (maxvariant - genedata[i])/maxvariant if maxvariant > 0 else 0
+        else:
+            if cap:
+                gvfitness[i] = genedata[i]/(maxvariant-minvariant) if maxvariant > 0 else 0
+            else:
+                gvfitness[i] = genedata[i]/maxvariant if maxvariant > 0 else 0
+    return gvfitness
+        
+
+def compute_organism_fitness(organism, genefitness):
+    """Computes the (linear) organism fitness.
+    
+    Dot product of organism and genefitness.
+
+    Args:
+        organism (vector of shape `(1, m)`):
+            The gene variant fitness values of a single organism.
+        genefitness (vector of shape `(1, m)`):
+            The list of gene fitness values.
+    
+    Returns:
+        A float, the linear organism fitness.
+    """
+    ofitness = 0.0
+    for j in range(0, len(organism)):
+        ofitness += organism[j]*genefitness[j]
+    return ofitness
+
+def compute_all_organism_fitness(population, genefitness):
+    """Computes the (linear) organism fitness values for a population.
+
+    Args:
+        population (matrix of shape `(n, m)`):
+            The population data in matrix form, rows are organisms,
+            colums genes.
+        genefitness (vector of shape `(1, m)`):
+            The list of gene fitness values.
+    
+    Returns:
+        A vector of shape `(n, 1)`, the list of fitness values
+        of the organisms in the population.
+    """
+    n = population.shape[0]
+    populationfitness = np.zeros(n)
+    for i in range(0, n):
+        populationfitness[i] = compute_organism_fitness(population[i,:], genefitness)
+    return populationfitness
+
+
+def compute_gene_deltas(geneindex, genevariantfitness, gene, organism, genefitness,  
+                        genesimilarity, strategy="GS Dominant"):
+    """Computes delta values stemming from the gene strategy.
+
+    Args:
+        geneindex (integer):
+            The index j for which gene index the delta is to be computed.
+        genevariantfitness (float):
+            the gene variant fitness at i,j.
+        gene (float vector of shape `(1, n)`):
+            the current gene vector.
+        organism (float vector of shape `(m, 1)`):
+            the current organism vector.
+        genefitness (float vector of shape `(1, m)`):
+            The list of gene fitness values.
+        genesimilarity (float vector of shape `(1, m)`):
+            The kinship of the current gene to the others.
+        strategy (string):
+            The evolutionary strategy to be applied.
+         
+    Returns:
+        A float, the Delta(i,j) value for a particular gene 
+        and organism, respectively.
+    """    
+    n = len(gene)
+    m = len(organism)
+    if strategy == "GS Dominant":
+        deltaG = 1/float(n)*genefitness[geneindex]*(genevariantfitness-1/2)*2
+    elif strategy == "GS Selfish":
+        deltaG = 0
+        for j in range(0, m):
+            if j == geneindex:
+                continue
+            deltaG += -1/float(n)*genesimilarity[j]*genefitness[geneindex]*\
+                                  (genevariantfitness-1/2)*(organism[j] - genevariantfitness)
+        deltaG  = deltaG/float(m)
+    elif strategy == "GS Kin-Altruistic":
+        deltaG = 0
+        for j in range(0, m):
+            if j == geneindex:
+                continue
+            deltaG += 1/float(n)*(0.5-genesimilarity[j])*genefitness[geneindex]*\
+                                (genevariantfitness-1/2)*(organism[j] - genevariantfitness)
+        deltaG  = deltaG/float(m)
+    elif strategy == "GS Altruistic":
+        deltaG = 0
+        for j in range(0, m):
+            if j == geneindex:
+                continue
+            deltaG += 1/float(n)*genesimilarity[j]*genefitness[geneindex]*(genevariantfitness-1/2)*\
+                                genefitness[j]*(organism[j] - genevariantfitness)
+        deltaG  = deltaG/float(m)
+    elif strategy == "GS None":
+        deltaG = 0
+    else:
+        raise NameError("Unknown gene strategy:" + strategy)
+    
+    return deltaG
+
+def compute_organism_deltas(orgindex, population, genefitness,
+                            orgfitness, orgsimilarity, strategy="OS Balance"):
+    """Computes delta values stemming from the organism strategy.
+
+    Args:
+        orgindex (integer):
+            The index i of the current organism.
+        population (matrix of shape `(n, m)`):
+            The full population matrix obtained by applying the
+            gene variant fitness functions to the input data.
+        genefitness (float vector of shape `(1, m)`):
+            The list of gene fitness values.
+        orgfitness (float vector of shape `(n, 1)`):
+            The list of organism fitness values.
+        orgsimilarity (float vector of shape `(n, 1)`):
+            The kinship of the current organism to the others.
+        strategy (string):
+            The evolutionary strategy to be applied.
+    
+    Returns:
+        A vector shape `(0, m)` containing the changes to the gene
+        fitness for the particular organism.
+    """
+    n = population.shape[0]
+    m = population.shape[1]
+    
+    deltaO = np.zeros(m)
+    if strategy == "OS Balanced":
+        for j in range(0, m):
+            genecontribution = population[orgindex, j]*genefitness[j]
+            if orgfitness[orgindex] == 0:
+                deltaO[j] = 0
+            else:
+                deltaO[j] = -1/n*(genecontribution/orgfitness[orgindex] - 1/m)*orgfitness[orgindex]
+    elif strategy == "OS Altruistic":
+        for i in range(0, n):
+            if i == orgindex:
+                continue
+            
+            for j in range(0, m):
+                genecontribution = population[orgindex, j]*genefitness[j]
+                if orgfitness[orgindex] == 0:
+                    deltaO[j] = 0
+                else:
+                    deltaO[j] += -1/n*orgsimilarity[i]*(genecontribution/orgfitness[orgindex] - 1/m)*\
+                                (1/n)*(orgfitness[orgindex]-orgfitness[i])
+    elif strategy == "OS Kin-Selfish":
+        for i in range(0, n):
+            if i == orgindex:
+                continue
+            
+            for j in range(0, m):
+                genecontribution = population[orgindex, j]*genefitness[j]
+                if orgfitness[orgindex] == 0:
+                    deltaO[j] = 0
+                else:
+                    deltaO[j] += 1/n*(0.5-orgsimilarity[i])*(genecontribution/orgfitness[orgindex] - 1/m)*\
+                                (1/n)*(orgfitness[orgindex]-orgfitness[i])
+                
+    elif strategy == "OS Selfish":
+        for i in range(0, n):
+            if i == orgindex:
+                continue
+           
+            for j in range(0, m):
+                genecontribution = population[orgindex, j]*genefitness[j]
+                if orgfitness[orgindex] == 0:
+                    deltaO[j] = 0
+                else:
+                    deltaO[j] += -1/n*orgsimilarity[i]*(genecontribution/orgfitness[orgindex] - 1/m)*\
+                                (1/n)*(orgfitness[orgindex]-orgfitness[i])
+    elif strategy == "OS None":
+        pass
+    else:
+        raise NameError("Unknown organism strategy:" + strategy)
+    return deltaO
+
+def iteration(population, genefitness, genesimilarity,
+              orgsimilarity, strategy, silent=False):
+    """Runs a single, evolutionary step.
+
+    One iteration takes a given population and gene fitness,
+    calculates a new gene and organism fitness.
+
+    Args:
+        population (matrix of shape `(n, m)`):
+            The population data in matrix form, rows are organisms,
+            colums genes.
+        genefitness (vector of shape `(1, m)`):
+            The list of gene fitness values.
+        genesimilarity (matrix of shape `(m, m)`):
+            The symmetric gene kinship matrix.
+        orgsimilarity (matrix of shape `(n, n)`):
+            The symmetric organism kinship matrix.
+        strategy (string vector of length 2):
+            Defines the used gene and organism strategy, respectively.
+    
+    Returns:
+        Two vectors, first, the new gene fitness of shape `(1, m)`,
+        second, the organism fitness values of shape `(n, 1)`
+    """
+    n = population.shape[0]
+    m = population.shape[1]
+
+    # get Delta contributions to gene fitness updates
+    deltaGs = np.zeros([n,m])
+    deltaOs = np.zeros([n,m])
+    orgfitness = np.zeros([n,1])
+    for i in range(0, n):
+        orgfitness[i] = compute_organism_fitness(population[i,:], genefitness)
+
+    for i in range(0, n):
+        deltaOs[i,:] = compute_organism_deltas(i, population, genefitness, orgfitness, orgsimilarity[i,:], strategy[1])
+        for j in range(0, m):
+            deltaGs[i,j] = compute_gene_deltas(j, population[i,j], population[:,j], population[i,:], genefitness,
+                                               genesimilarity[j,:], strategy[0])
+    if not silent:  
+        print("deltaGs = ", deltaGs)
+        print("deltaOs = ", deltaOs)
+    deltas = deltaGs + deltaOs
+    deltaG = np.sum(deltaGs,axis=0)
+    deltaO = np.sum(deltaOs,axis=0)
+    delta = np.sum(deltas,axis=0)
+    if not silent:
+        print("deltaG = ", deltaG)
+        print("deltaO = ", deltaO)
+        print("delta = ", delta)
+
+    # apply replicator equations
+    newgenefitness = np.zeros(m)
+    for j in range(0, m):
+        newgenefitness[j] = genefitness[j]*(1+delta[j])
+    sumfitness = sum(newgenefitness)
+    for j in range(0, m):
+        newgenefitness[j] /= sumfitness
+    neworganismfitness = compute_all_organism_fitness(population, newgenefitness)
+    
+    return newgenefitness, neworganismfitness
+
+def compute_gene_similarity(population):
+    """Computes the similarity/kinship matrix for genes.
+
+    Args:
+        population (matrix of shape `(n, m)`):
+            The population data in matrix form, rows are organisms,
+            colums genes.
+    
+    Returns:
+        the similarity matrix `(m, m)`,
+    """
+    n = population.shape[0]
+    m = population.shape[1]
+    genediversity = np.zeros([m,m])
+    for j in range(0,m):
+        for l in range(0,m):
+            tmp = np.linalg.norm(population[:,j] - population[:,l])
+            genediversity[j,l] += tmp
+                
+    genesimilarity = 1 - genediversity/float(n)
+    print("Gene similarity = ")
+    print(genesimilarity)
+    return genesimilarity
+
+def compute_organism_similarity(population):
+    """Computes the similarity/kinship matrix for organisms.
+
+    Args:
+        population (matrix of shape `(n, m)`):
+            The population data in matrix form, rows are organisms,
+            colums genes.
+    
+    Returns:
+        the similarity matrix `(n, n)`,
+    """
+    n = population.shape[0]
+    m = population.shape[1]
+    orgdiversity = np.zeros([n,n])
+    for i in range(0, n):
+        for l in range(0, n):
+            tmp = np.linalg.norm(population[i,:] - population[l,:])
+            orgdiversity[i,l] += tmp
+                
+    orgsimilarity = 1 - orgdiversity/float(m)
+    print("Organism similarity = ")
+    print(orgsimilarity)
+    return orgsimilarity
+
+
+
+
+

pikaia-0.0.2/src/pikaia/examples.py

@@ -0,0 +1,107 @@
+import numpy as np
+import string
+
+import pikaia.alg
+
+
+rawdata3x3 = np.zeros([3,3])
+rawdata3x3[:,:] = [[ 300, 10, 2],
+                   [ 600,  5, 2],
+                   [1500,  4, 1]]
+
+rawdata10x5 = np.zeros([10,5])
+rawdata10x5[:,:] = [[300, 10 , 2, 0, 2.5],
+                    [600, 5, 2, 1, 3.0], 
+                    [1500, 4, 1, 2, 4.0],
+                    [400, 8, 2, 0, 3.5],
+                    [500, 8, 2, 1, 3.0],
+                    [700, 5, 2, 1, 4.5],
+                    [900, 6, 1, 1, 4.0],
+                    [1100, 6, 1, 2, 3.5],
+                    [1300, 5, 2, 2, 5.0],
+                    [1700, 4, 1, 2, 5.0]]
+
+class Example:
+    
+    def __init__(self, inputdata, genelabels=None, orgslabels=None, labelpostfix=None):
+        self._data = inputdata  
+        self._genelabelsbase = genelabels
+        if self._genelabelsbase is None:
+            self._genelabels = self._genelabelsbase
+        else:
+            self._genelabels = []
+            for k, pf in enumerate(labelpostfix):
+                # import pdb; pdb.set_trace()
+                self._genelabels.append([])
+                for j in range(0, self._data.m):
+                    self._genelabels[k].append(self._genelabelsbase[j] + pf)
+
+        self._orgslabelsbase = orgslabels
+        if self._orgslabelsbase is None:
+            self._orgslabels = self._orgslabelsbase
+        else:    
+            self._orgslabels = []
+            for k, pf in enumerate(labelpostfix):
+                self._orgslabels.append([])
+                for i in range(0, self._data.n):
+                    self._orgslabels[k].append(self._orgslabelsbase[i] + pf)
+                        
+    @property
+    def exampledata(self):
+        return self._data
+
+    def get_gene_labels(self, set=0):
+        return self._genelabels[set]
+    
+    def get_org_labels(self, set=0):
+        return self._orgslabels[set]
+
+
+def assemble_example(specifier):
+    """Returns a setup ready for modelling.
+
+    Returns a datastructure for Genetic Ai including
+    model and ploting parameters.
+
+    Args:
+        specifier (string):
+        Giving '3x3-DomBal+AltSal' returns a small example
+        with n=3 and m=3;
+        Giving '10x5-DomBal+AltSal' returns a larger example
+        with n=10 and m=5.
+            
+    
+    Returns:
+        an Example data structure.
+    """
+    if specifier == "3x3-DomBal+AltSal":
+        
+        gvfitnessrules = ["inv_percentage", "inv_percentage", "inv_percentage"]
+        inputdata = pikaia.alg.Population(rawdata3x3, gvfitnessrules)
+
+        # defining plotting labels
+        genelabels = ["gene 1 = price", "gene 2 = time", "gene 3 = stops"]
+        orgslabels = []
+        for i in range(0, inputdata.n):
+            orgslabels.append("flight " + string.ascii_uppercase[i])
+        labelpostfixes = ["(DomBal)", "(AltSel)"]
+
+        return Example(inputdata, genelabels, orgslabels, labelpostfixes)
+
+    if specifier == "10x5-DomBal+AltSal":
+        
+        gvfitnessrules = ["inv_percentage", "inv_percentage", "inv_percentage",
+                          "percentage", "percentage"] 
+        inputdata = pikaia.alg.Population(rawdata10x5, gvfitnessrules)
+        genelabels = ["gene 1 = price", "gene 2 = time", "gene 3 = stops",
+                      "gene 4 = luggage", "gene 5 = rating"]
+        orgslabels = []
+        for i in range(0, inputdata.n):
+            orgslabels.append("flight " + string.ascii_uppercase[i])
+        labelpostfixes = ["(DomBal)", "(AltSel)"]
+
+        return Example(inputdata, genelabels, orgslabels, labelpostfixes)
+        
+            
+    else:
+        raise ValueError("Unknown example specifier")

pikaia-0.0.2/src/pikaia/plot.py

@@ -0,0 +1,162 @@
+import matplotlib.pyplot as plt
+import matplotlib
+import numpy as np
+import string
+
+import pikaia.alg
+
+def initialize_plotting_variables():
+    """Initialize styles and markers for plotting.
+
+    
+    Returns:
+        linestyles (list of linestyle specifiers).
+        two sets of markers (list of strings).
+    """
+    
+    matplotlib.rcParams['pdf.fonttype'] = 42
+    matplotlib.rcParams['ps.fonttype'] = 42
+    linestyle_str = [
+     ('solid', 'solid'),      # Same as (0, ()) or '-'
+     ('dotted', 'dotted'),    # Same as ':'
+     ('dashed', 'dashed'),    # Same as '--'
+     ('dashdot', 'dashdot')]  # Same as '-.'
+    linestyle_tuple = [
+     ('densely dashdotted',    (0, (3, 1, 1, 1))),
+     ('dashdotted',            (0, (3, 5, 1, 5))),
+     ('loosely dotted',        (0, (1, 10))),
+     ('dotted',                (0, (1, 5))),
+     ('densely dotted',        (0, (1, 1))),
+     ('long dash with offset', (5, (10, 3))),
+     ('loosely dashed',        (0, (5, 10))),
+     ('dashed',                (0, (5, 5))),
+     ('densely dashed',        (0, (5, 1))),
+     ('loosely dashdotted',    (0, (3, 10, 1, 10))), 
+     ('dashdotdotted',         (0, (3, 5, 1, 5, 1, 5))),
+     ('loosely dashdotdotted', (0, (3, 10, 1, 10, 1, 10))),
+     ('densely dashdotdotted', (0, (3, 1, 1, 1, 1, 1)))]
+    linestyles = []
+    for i, (name, linestyle) in enumerate(linestyle_str):
+        linestyles.append(linestyle)
+    for i, (name, linestyle) in enumerate(linestyle_tuple):
+        linestyles.append(linestyle)
+    markerstylesSet1 = ["o","^","s", ">", "p", "X", ".", "*", "1", "3"]
+    markerstylesSet2 = ["x","v", "D","<", "P", "h", "8", "d", "2", "4"]
+    return linestyles, markerstylesSet1, markerstylesSet2
+
+def plot_gene_fitness(modellist, figurenr, show=True, savename=None,
+                      fontsize=12, linewidth=3):
+    """Plots the gene fitness values over iterations.
+
+    Args:
+        modellist (List of geneticai models):
+            List of geneticai models to be plotted.
+        figurenr (integer):
+            The figure window specifier.
+        show (boolean):
+            Whether the finished plots are shown.
+        savename (String):
+            Whether the finished plots are saved as png and pdf.
+        fontsize (integer):
+            Fontsizes in the plots
+        linewidth (integer):
+            Linewidths in the plots
+           
+
+    """
+    
+    plt.figure(figurenr)
+    plt.rcParams.update({'font.size': fontsize})
+    
+    maxpiter = 0
+    for model in modellist:
+        if model._iterESE > maxpiter:
+            maxpiter = model._iterESE
+    
+    if maxpiter > 20:
+        inc = round(maxpiter/10)
+        plt.xticks(range(0,maxpiter, inc)) 
+    else:
+        inc = 5
+        plt.xticks(range(0,maxpiter)) 
+
+    
+    for model in modellist:
+        n = model._gps.shape[1]
+        for j in range(0, n):
+            plt.plot(range(0, model._iterESE+1), model._gps[:model._iterESE+1,j],
+                    label=model._genelabels[j], linestyle=model._linestyles[j],
+                    marker=model._markerstyles[j], markersize=8, markevery=inc,
+                    lw=linewidth)
+        plt.ylabel('gene fitness [%]')
+        plt.xlabel('iterations')
+        
+    
+    plt.xlim(0,maxpiter)
+    plt.legend(handlelength=5, fontsize=10)
+    if savename is not None:
+        plt.savefig(savename + ".pdf", format="pdf", bbox_inches="tight")
+        plt.savefig(savename + ".png", format="png", bbox_inches="tight")
+    if show:
+        plt.show()
+
+def plot_organism_fitness(modellist, figurenr, maxitershown, show=True, savename=None,
+                          fontsize=12, linewidth=3):
+    
+    """Plots the organism fitness values over iterations.
+
+    Args:
+        modellist (List of geneticai models):
+            List of geneticai models to be plotted.
+        figurenr (integer):
+            The figure window specifier.
+        maxitershown (integer):
+            The maximum iteration shown in the plot.
+        show (boolean):
+            Whether the finished plots are shown.
+        savename (String):
+            Whether the finished plots are saved as png and pdf.
+        fontsize (integer):
+            Fontsizes in the plots
+        linewidth (integer):
+            Linewidths in the plots
+           
+
+    """
+    plt.figure(figurenr)
+    plt.rcParams.update({'font.size': fontsize})
+    
+    
+    maxpiter = 0
+    for model in modellist:
+        if model._iterESE > maxpiter:
+            maxpiter = model._iterESE
+    
+    if maxitershown is not None and maxitershown < maxpiter:
+        maxpiter = maxitershown
+    
+    if maxpiter > 20:
+        inc = round(maxpiter/10)
+        plt.xticks(range(0,maxpiter, inc)) 
+    else:
+        inc = 5
+        plt.xticks(range(0,maxpiter)) 
+
+    
+    for model in modellist:
+        n = model._ofs.shape[1]
+        for j in range(0, n):
+            plt.plot(range(0, model._iterESE+1), model._ofs[:model._iterESE+1,j],
+                    label=model._orgslabels[j], linestyle=model._linestyles[j],
+                    marker=model._markerstyles[j], markersize=8, markevery=inc,
+                    lw=linewidth)
+        plt.ylabel('organism fitness [%]')
+        plt.xlabel('iterations')
+        
+    plt.xlim(0,maxpiter)
+    plt.legend(handlelength=5, fontsize=10)
+    if savename is not None:
+        plt.savefig(savename + ".pdf", format="pdf", bbox_inches="tight")
+        plt.savefig(savename + ".png", format="png", bbox_inches="tight")
+    if show:
+        plt.show()

pikaia-0.0.2/src/pikaia/search.py

@@ -0,0 +1,116 @@
+import datetime
+
+import numpy as np
+
+import pikaia as gai
+import pikaia.alg
+
+class Search:
+    """
+    Class that performs a string-based search over a data matrix
+    using Genetic AI.
+    """
+
+    def __init__(self, input_data, orgs_labels, gene_labels):
+        self._data = input_data  
+        self._gene_labels = gene_labels
+        self._orgs_labels = orgs_labels
+
+    def search_request(self, query: str, top_k: int = None, silent=False) -> list:
+        """
+        Performs a search request on the data given a query string.
+
+        Args:
+            query (str): a string containing comma-separated keywords.
+            top_k (int): how many top-ranked organisms to return.
+        
+        Returns:
+            Tuple[list, list] containing the organism and gene fitness
+            values at the end of the simulation.
+        """
+        # Process query
+        split_query = [f.strip().lower() for f in query.split(",")]
+        query_features = [f for f in split_query if f in self._gene_labels]
+        query_feature_ids = [self._gene_labels.index(f) for f in query_features]
+        query_year = next((int(f) for f in split_query if is_year(f)), 0)
+
+        # For testing purposes set row cutoff
+        cutoff = None
+        if cutoff is None:
+            cutoff = self._data.shape[0]
+
+        # Get the relevant colum for each feature and create a new matrix
+        data_subset = self._data[:cutoff, query_feature_ids]
+
+        # Use percentage rule for all features except year
+        gvfitnessrules = ["percentage"] * len(query_features)
+
+        # Get relevant columns from matrix
+        if query_year > 0:
+            # Convert year column -> calculate the distance to the year in the query
+            year_col = abs(self._data[:cutoff, self._gene_labels.index("year")] - query_year)
+
+            # Add to the data_subset
+            data_subset = np.column_stack((data_subset, year_col))
+
+            # Special handling for year
+            gvfitnessrules += ["inv_percentage"]
+
+        # Print logs
+        print("Selected features:", query_features, f"(ids: {query_feature_ids})")
+        print("Number of non-zero values per selected feature:")
+        for f_id, f in zip(query_feature_ids, query_features):
+            print(f" - {f}:", len([w for w in self._data[:, f_id] if w != 0]))
+
+        print(f"Subset of data matrix (shape: {data_subset.shape})\n", data_subset)
+
+        # Convert raw data to population
+        population = pikaia.alg.Population(data_subset, gvfitnessrules)
+
+        strategy = ["GS Dominant", "OS Balanced"]
+        # Use this for AltSel strategies (reduce maxiter for performance)
+        # strategy = ["GS Altruistic", "OS Selfish"]
+
+        # Initialize model
+        model = gai.alg.Model(population, strategy)
+
+        # Start with a uniform distribution
+        n_features = data_subset.shape[1]
+        initialgenefitness = [1 / n_features] * n_features
+
+        # Run simulation
+        e = 0.00005
+        gene_fitness, fitness = model.complete_run(initialgenefitness, maxiteration=100,
+                                                   epsilon=e, silent=silent)
+
+        # Function to get all non-zero features for a selected organism
+        def get_features(organism):
+            org_index = self._orgs_labels.index(organism)
+            return [f_name for f_weight, f_name in zip(self._data[org_index,:], self._gene_labels)
+                    if f_weight != 0]
+
+        # Function to get the feature values for a selected organism 
+        def get_feature_values(organism):
+            org_index = self._orgs_labels.index(organism)
+            return [(f_name, f_weight)
+                    for f_weight, f_name in zip(data_subset[org_index,:], query_features)]
+
+        # Sort organisms with their corresponding fitness value
+        org_fitness = list(sorted(
+            [(org_label, fit, get_feature_values(org_label))
+             for org_label, fit in zip(self._orgs_labels, fitness)],
+            key=lambda x: x[1],
+            reverse=True
+        ))
+
+        gene_fitness_labels = [(l, f) for l, f in zip(query_features, gene_fitness)]
+        # Return the top_k fittest organisms
+        return org_fitness[:top_k], gene_fitness_labels
+
+def is_year(s):
+    """Checks if a string is a year number."""
+    try:
+        year = int(s)
+    except ValueError:
+        return False
+    return year >= 1890 and year <= datetime.date.today().year + 1