Struct BiomedicalEmbedding 

pub struct BiomedicalEmbedding {

    pub config: BiomedicalEmbeddingConfig,
    pub model_id: Uuid,
    pub gene_embeddings: HashMap<String, Array1<f32>>,
    pub protein_embeddings: HashMap<String, Array1<f32>>,
    pub disease_embeddings: HashMap<String, Array1<f32>>,
    pub drug_embeddings: HashMap<String, Array1<f32>>,
    pub compound_embeddings: HashMap<String, Array1<f32>>,
    pub pathway_embeddings: HashMap<String, Array1<f32>>,
    pub relation_embeddings: HashMap<String, Array1<f32>>,
    pub entity_types: HashMap<String, BiomedicalEntityType>,
    pub relation_types: HashMap<String, BiomedicalRelationType>,
    pub triples: Vec<Triple>,
    pub features: BiomedicalFeatures,
    pub training_stats: TrainingStats,
    pub model_stats: ModelStats,
    pub is_trained: bool,
}

Biomedical knowledge graph embedding model

Fields

config: BiomedicalEmbeddingConfig

model_id: Uuid

gene_embeddings: HashMap<String, Array1<f32>>

Entity embeddings by type

protein_embeddings: HashMap<String, Array1<f32>>

disease_embeddings: HashMap<String, Array1<f32>>

drug_embeddings: HashMap<String, Array1<f32>>

compound_embeddings: HashMap<String, Array1<f32>>

pathway_embeddings: HashMap<String, Array1<f32>>

relation_embeddings: HashMap<String, Array1<f32>>

Relation embeddings by type

entity_types: HashMap<String, BiomedicalEntityType>

Entity type mappings

relation_types: HashMap<String, BiomedicalRelationType>

Relation type mappings

triples: Vec<Triple>

Training data

features: BiomedicalFeatures

Biomedical-specific features

training_stats: TrainingStats

Training and model stats

model_stats: ModelStats

is_trained: bool

Implementations

impl BiomedicalEmbedding

pub fn new(config: BiomedicalEmbeddingConfig) -> Self

Create new biomedical embedding model

pub fn model_type(&self) -> &str

Get the model type identifier

pub fn is_trained(&self) -> bool

Check if the model has been trained

pub fn add_gene_disease_association( &mut self, gene: &str, disease: &str, score: f32, )

Add gene-disease association

pub fn add_drug_target_interaction( &mut self, drug: &str, target: &str, affinity: f32, )

Add drug-target interaction

pub fn add_pathway_membership( &mut self, entity: &str, pathway: &str, score: f32, )

Add pathway membership

pub fn add_protein_interaction( &mut self, protein1: &str, protein2: &str, score: f32, )

Add protein-protein interaction

pub fn get_typed_entity_embedding(&self, entity: &str) -> Result<Vector>

Get entity embedding with biomedical type awareness

pub fn predict_gene_disease_associations( &self, gene: &str, k: usize, ) -> Result<Vec<(String, f64)>>

Predict gene-disease associations

pub fn predict_drug_targets( &self, drug: &str, k: usize, ) -> Result<Vec<(String, f64)>>

Predict drug targets

pub fn find_pathway_entities( &self, pathway: &str, k: usize, ) -> Result<Vec<(String, f64)>>

Find pathway-related entities

Trait Implementations

impl Clone for BiomedicalEmbedding

fn clone(&self) -> BiomedicalEmbedding

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BiomedicalEmbedding

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BiomedicalEmbedding

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EmbeddingModel for BiomedicalEmbedding

fn config(&self) -> &ModelConfig

fn model_id(&self) -> &Uuid

fn model_type(&self) -> &'static str

fn add_triple(&mut self, triple: Triple) -> Result<()>

fn train<'life0, 'async_trait>( &'life0 mut self, epochs: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<TrainingStats>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_entity_embedding(&self, entity: &str) -> Result<Vector>

fn get_relation_embedding(&self, relation: &str) -> Result<Vector>

fn score_triple( &self, subject: &str, predicate: &str, object: &str, ) -> Result<f64>

fn predict_objects( &self, subject: &str, predicate: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn predict_subjects( &self, predicate: &str, object: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn predict_relations( &self, subject: &str, object: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn get_entities(&self) -> Vec<String>

fn get_relations(&self) -> Vec<String>

fn get_stats(&self) -> ModelStats

fn save(&self, _path: &str) -> Result<()>

fn load(&mut self, _path: &str) -> Result<()>

fn clear(&mut self)

fn is_trained(&self) -> bool

fn encode<'life0, 'life1, 'async_trait>( &'life0 self, texts: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<f32>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Encode text strings into embeddings

impl Serialize for BiomedicalEmbedding

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.