openfreeenergy / konnektor Goto Github PK

this is about the network showcase notebook,

This is one clustering approach.

Content:

• Paper: https://pubmed.ncbi.nlm.nih.gov/32584031/
• JNB example: https://github.com/greglandrum/rdkit_blog/blob/master/notebooks/Scaffold%20Network%20-%20Interactive%20Views%20and%20Exploring%20the%20Options.ipynb

Collecting Visualization ideas here:

• Build Network graph visualization
• make bottlenecks visible
• interactive visualization (checkout swensons solution fo this)
• large number of nodes?
• [ ]

Here we could start adding a heuristic Maximal Network Lister. This one tries N random mappings for the ligands.

General Idea:

• Build a network planner, that clusters nodes, builds sub networks and then concatenates the sub networks.
• each edge is labelled accordingly.

See here for an example: https://github.com/choderalab/feflow/blob/main/.git-blame-ignore-revs

Todo:

• make Konnektor importable into Openfe
• replace old ligand network planners.
• make Konnektor Options accessible from CLI
• test equality

Usually I expect a Generator to have __iter__ defined, but the pattern used seems a lot closer to a factory pattern.

Would it make sense to not call it "Generator" to avoid Python confusion?

Thoughts:

• Use Scaffold Network Class from RDkit.
• what can we do about 3D?

Improve Unit Test coverage.
needs to be seperated into more subtasks.

check base classes and refactor them to new gufe!

Build Userstories, that help understanding how the Konnektor functionality can be used to solve problems.

ToDo:

• Build Design Usersheet
• Add to the docs.

Is your feature request related to a problem? Please describe.
add code bit to Cyclic graph planner, making node connections more diverse

Something like

network = generate_explicit_network([mapper1, mapper2], [(ligand1, ligand2), (ligand2, ligand3), ...])

(Based on meeting with Joe Bluck, this might be useful, especially when benchmarking against other tools.)

Here i need help from the team, giving feeback on repo structures and names

Todos:

• Refactor algorithms folder (remove them and merge the files into the folder structure)
• is the Graph generator and bi-partite graph concatentor seperation needed?

This abstract class will be transferred to Gufe in the end.

This is an idea for a feature.
one could make the redundancy creation in the the N-NodeEdges Network dependent on a scorer threshold.
so if score is 1, no redundancy needed, if score <0.5 add redundancy due to likely edge failure.

same pattern as:
https://github.com/OpenFreeEnergy/konnektor/blob/main/src/konnektor/network_tools/cluster_molecules.py

Imrpove the readability of the repository by refactoring the codebase with black.

Implement different Clustering Algorithms:

• allow featurization and clustering in one go.

General ideas for tools:

Tools (Helper Functions):

• concatenate(networks: Iterable[LigandNetwork], _concatenator:NetworkConcatator) ->LigandNetwork
• merge(networks: Iterable[LigandNetwork]) ->LigandNetwork
• appendCompound(network: LigandNetwork, compound:Iterable[Compound], _concatenator:NetworkConcatator)-> LigandNetwork
• removeCompound(network: LigandNetwork, compound:Iterable[Compound], _concatenator:NetworkConcatator)-> LigandNetwork

Concatenator Implementations:

• MST Concatenator(networks: Iterable[LigandNetwork], _concatenator:NetworkConcatator) ->LigandNetwork
• Cyclic Concatenator(networks: Iterable[LigandNetwork], _concatenator:NetworkConcatator) ->LigandNetwork

here we should define some helping functions for the analysis of networks.

generall function should look like:
def ana(Network) -> any

Functions:

• isConnected->bool
• edgeRedundancy->float
• nodeConnectivity->dict{int, float}
• cyclesForNode(network, cycleSize)->dict{int, float} - Difficult!
• getGraphScore(network, scorer)->float
• getGraphRobustness(network)->float

new ideas, please add

Add feature as a new clustering class.

Todo:

• Make scorer passable
• Make Distance matrix passable

Is your feature request related to a problem? Please describe.
flex it such we can use different ways connecting clusters.

Change the network planning calls in jnb and other doc areas to .generate_ligand_network

Enable selecting one node and build cylces around it.

Network Graph Generators are generating networks from compounds, using mappers and scorers.

general method signature of the main functionality:

def generate_ligand_network(self, ligands: Iterable[SmallMoleculeComponent]) ->LigandNetwork

Implement/transfer the following Graph Generator Algorithms:

• MST
• Redundant MST
• Star / Radial Map
• Starry Sky
• Cyclic Graph
• Maximal Graph

https://github.com/OpenFreeEnergy/konnektor/blob/193a55d3710022b7ab255faf6378039148c54539/src/konnektor/visualization/widget.py#L11C1-L12C20

The konnektor_example.ipynb should be intergrated as a tutorial to the sphinx docs.

is already part of GUFE

remove:

  plt.figure... 
   fig.gca()

maybe replace plt.figure with plt.subplots

additionalExample: https://github.com/dwhswenson/contact_map/blob/7fbb0b037db01831f8fd9ddd8710e9e0d23a25c5/contact_map/contact_count.py#L274

https://github.com/OpenFreeEnergy/konnektor/blob/9a091c03254d605dc917df3408a6e95f7a3aa27f/src/konnektor/visualization/visualization.py#L44C15-L44C41

Add documentation:

• Small theoretic analysis of different networks
• Tutorial
• API Ref