医药领域知识图谱的构建方法

    import openrefine_client as refine
    
    # 创建项目
    project = refine.Refine(refine.RefineServer()).new_project("data.csv")
    
    # 数据清洗操作
    project.text_transform(column="drug_name", expression="value.strip().lower()")
    project.cluster(column="drug_name", method="keycollision", params={"function": "fingerprint"})
    project.merge_clusters(column="drug_name", clusters=[{"cluster": [{"value": "aspirin", "count": 10}, {"value": "asprin", "count": 2}], "merge": True, "name": "aspirin"}])
    
    # 导出清洗后的数据
    project.export(export_format="csv", file="cleaned_data.csv")
    
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    from transformers import BertTokenizer, BertForTokenClassification
    import torch
    
    tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
    model = BertForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    
    text = "Aspirin is used to treat pain, fever, and inflammation."
    inputs = tokenizer(text, return_tensors="pt")
    outputs = model(**inputs)
    
    predictions = torch.argmax(outputs.logits, dim=2)
    entities = tokenizer.convert_ids_to_tokens(inputs.input_ids.squeeze())
    entity_labels = [model.config.id2label[prediction] for prediction in predictions.squeeze()]
    
    for entity, label in zip(entities, entity_labels):
    if label != "O":
        print(f"{entity}: {label}")
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    from transformers import BertTokenizer, BertForSequenceClassification
    import torch
    
    tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
    model = BertForSequenceClassification.from_pretrained("path/to/your/trained/model")
    
    text = "Aspirin is used to treat pain, fever, and inflammation."
    inputs = tokenizer(text, return_tensors="pt")
    outputs = model(**inputs)
    
    predictions = torch.argmax(outputs.logits, dim=1)
    relation_label = model.config.id2label[predictions.item()]
    
    print(f"Relation: {relation_label}")
    
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    from fuzzywuzzy import fuzz
    
    def entity_alignment(entity1, entity2):
    similarity = fuzz.token_sort_ratio(entity1, entity2)
    if similarity > 80:
        return True
    else:
        return False
    
    entity1 = "Aspirin"
    entity2 = "Asprin"
    
    if entity_alignment(entity1, entity2):
    print(f"{entity1} and {entity2} are the same entity.")
    else:
    print(f"{entity1} and {entity2} are different entities.")
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    from fuzzywuzzy import fuzz
    
    def relation_alignment(relation1, relation2):
    similarity = fuzz.token_sort_ratio(relation1, relation2)
    if similarity > 80:
        return True
    else:
        return False
    
    relation1 = "treats"
    relation2 = "treat"
    
    if relation_alignment(relation1, relation2):
    print(f"{relation1} and {relation2} are the same relation.")
    else:
    print(f"{relation1} and {relation2} are different relations.")
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import torch
    import torch.nn as nn
    import torch.optim as optim
    from torch_geometric.data import Data
    from torch_geometric.nn import GCNConv
    
    class GCN(nn.Module):
    def __init__(self):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(16, 32)
        self.conv2 = GCNConv(32, 64)
    
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = torch.relu(x)
        x = self.conv2(x, edge_index)
        return x
    
    # 构建图数据
    x = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]], dtype=torch.float).t()
    edge_index = torch.tensor([[0, 1, 1, 2], [1, 0, 2, 1]], dtype=torch.long)
    data = Data(x=x, edge_index=edge_index)
    
    # 训练模型
    model = GCN()
    optimizer = optim.Adam(model.parameters(), lr=0.01)
    criterion = nn.MSELoss()
    
    for epoch in range(100):
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, x)
    loss.backward()
    optimizer.step()
    
    print("Graph fusion completed.")
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读