O ChatGPT pode criar transformações de mensagens para você?

Artigo

Danusa Calixto · Set. 1, 2023 12min de leitura

#ChatGPT #FHIR #HL7 #Artificial Intelligence (AI) #HealthShare #InterSystems IRIS #Outro

Uma tarefa "grande" ou "pequena" para o ChatGPT?

Eu testei o modelo de programação do GPT da OpenAI há algumas semanas, para ver se ele consegue, por exemplo, fazer algumas transformações de mensagens entre protocolos de saúde. Ele "consegue", em um nível aparentemente razoável.

Já faz quase 3 semanas, o que é um tempo bastante longo para o ChatGPT, então me pergunto com que rapidez ele cresce e se poderia fazer alguns jobs de engenharia de integração para nós. Por exemplo, ele consegue criar uma ferramenta DTL de COS da InterSystems para transformar o HL7 em uma mensagem FHIR?

Imediatamente, obtive algumas respostas rápidas, em menos de um ou dois minutos.

Teste

Primeiro, quero testar se estou falando com o "cara" certo.

Pergunta 1: como converter mensagens HL7 V2.4 para FHIR STU3?

ChatGPT:

A conversão de mensagens HL7 V2.4 em FHIR STU3 envolve várias etapas, já que os dois padrões têm modelos e estruturas de dados diferentes. Aqui está uma visão geral de alto nível do processo:

Identifique os elementos de dados relevantes na mensagem HL7 que precisam ser mapeados para os recursos FHIR. Isso dependerá do caso de uso específico e dos dados sendo trocados.
Defina as regras de mapeamento para cada elemento de dados. Isso envolve identificar o recurso FHIR equivalente e o elemento que corresponde ao elemento de dados HL7 e qualquer transformação ou tradução necessária.
Escreva um programa ou um script que consiga extrair os dados da mensagem HL7, aplicar as regras de mapeamento e criar recursos FHIR correspondentes. Isso talvez envolva usar uma combinação de expressões regulares, bibliotecas de análise sintática e bibliotecas de criação de recursos FHIR.
Valide os recursos FHIR em relação à especificação STU3 para garantir que estejam em conformidade com o padrão e tenham todos os elementos necessários.

Aqui está um exemplo de como pode ser o processo de conversão de uma mensagem de observação HL7 V2.4 para um recurso FHIR STU3 Observation:

Identifique os elementos de dados relevantes na mensagem HL7, como o código de observação, o valor e as unidades.
Defina as regras de mapeamento para cada elemento de dados, como o mapeamento do código de observação HL7 para um CodeableConcept FHIR e o valor e as unidades para uma Quantity FHIR.
Escreva um programa ou um script que consiga extrair dados da mensagem HL7, aplicar as regras de mapeamento e criar um recurso FHIR Observation com os elementos apropriados.
Valide o recurso FHIR Observation em relação à especificação STU3 para garantir que tenha todos os elementos necessários e seja válido.

Os detalhes específicos da implementação dependerão da linguagem de programação e das bibliotecas usadas, além da mensagem HL7 específica e do recurso FHIR mapeado. É recomendável consultar as especificações HL7 e FHIR e buscar conselhos de especialistas, se necessário.

Além de estar correto, ele responde de maneira mais detalhada do que a maioria dos humanos. Isso chamou minha atenção, então vamos começar.

Pergunta 2: Você pode criar uma amostra de transformação no Python para converter HL7 em FHIR?

ChatGPT:

Claro! Aqui está uma amostra de snippet de código do Python que demonstra como converter uma mensagem HL7 em um recurso FHIR STU3 Observation:

from hl7apy import core
from fhir.resources.observation import Observation
# Parse the HL7 message
hl7_message = 'MSH|^~\&|SENDING_APP|SENDING_FACILITY|RECEIVING_APP|RECEIVING_FACILITY|20220527120512||ORU^R01|MSGID12345|P|2.4\r' \
              'OBX|1|NM|GLU^Glucose||100|mg/dL||N|||F|||20220527120512\r'
hl7_parsed = core.parse_message(hl7_message)

# Map HL7 elements to FHIR elements
observation = Observation()

observation.code = {
    "coding": [{
        "system": "http://loinc.org",
        "code": hl7_parsed.obx[0].observation_id.value,
        "display": hl7_parsed.obx[0].observation_id.value
    }]
}

observation.valueQuantity = {
    "value": hl7_parsed.obx[0].value.value,
    "unit": hl7_parsed.obx[0].units.value,
    "system": "http://unitsofmeasure.org",
    "code": hl7_parsed.obx[0].units.value
}

# Serialize the FHIR resource as JSON
observation_json = observation.json()

# Print the serialized FHIR resource
print(observation_json)

Esse código usa a biblioteca hl7apy para analisar a mensagem HL7 e extrair os elementos de dados relevantes e a classe fhir.resources.observation do módulo fhir.resources pra criar um recurso FHIR Observation.

Nesse exemplo, o código mapeia o ID de observação HL7 para o elemento de código FHIR, e o valor e as unidades HL7 para o elemento FHIR valueQuantity. O recurso FHIR é depois serializado como JSON usando o método json().

Observe que esse é um exemplo simples e você talvez precise mapear mais elementos de dados dependendo do caso de uso específico. Além disso, você precisará instalar as bibliotecas hl7apy e fhir.resources para executar esse código.

Não é uma resposta nada ruim — fornece um código boilerplate decente. Vamos dar um desafio um pouco específico agora:

Pergunta 3: Você pode fornecer uma amostra de transformação do HL7 V2 para FHIR Stu3 na DTL do COS da InterSystems?

ChatGPT:

Com certeza! Aqui está um exemplo de como transformar uma mensagem HL7 V2 em um recurso FHIR STU3 Observation na DTL (Linguagem de Transformação de Dados) do COS da InterSystems:

Class DTL.HL7toFHIR Extends %RegisteredObject
{

ClassMethod TransformHL7ToObservation(hl7Message As %String) As %String [ CodeMode = expression, DDLAllowed = 0 ]
{
    set src = ##class(EnsLib.HL7.Message).%New()
    set src.DocType = "2.4"
    set src.Parse(hl7Message)

    set obs = ##class(FHIR.Resource.Observation).%New()
    set obs.subject = { "reference": "Patient/"_src.MSH.GetSendingApplication() }
    set obs.status = "final"
    set loincCode = src.GetSegment("OBX", 1).GetField(3).GetField(1)
    set obs.code = { 
        "coding": [ 
            {
                "system": "http://loinc.org", 
                "code": loincCode, 
                "display": loincCode 
            }
        ]
    }

    set value = src.GetSegment("OBX", 1).GetField(5).GetField(1)
    set units = src.GetSegment("OBX", 1).GetField(6).GetField(1)
    set obs.valueQuantity = { 
        "value": value, 
        "unit": units, 
        "system": "http://unitsofmeasure.org", 
        "code": units 
    }

    quit obs.%ToJSON()
}

}

Esse código define um método de classe chamado TransformHL7ToObservation, que pega uma mensagem HL7 V2 como entrada e retorna um recurso FHIR STU3 Observation como uma string JSON.

O método primeiro cria um novo objeto EnsLib.HL7.Message e o usa para analisar a mensagem HL7 de entrada. Em seguida, ele cria um novo objeto FHIR.Resource.Observation e define os elementos subject e status.

Depois, o código extrai o LOINC, o valor e as unidades da mensagem HL7 e os mapeia para os elementos correspondentes no recurso FHIR.

Por fim, o método serializa o recurso FHIR como JSON e o retorna.

Para usar esse método de classe, você pode chamá-lo de outro método COS ou de um sistema externo usando a API REST da InterSystems. Aqui está um exemplo de como chamar o método de outro método COS:

set hl7Message = "MSH|^~\&|SENDING_APP|SENDING_FACILITY|RECEIVING_APP|RECEIVING_FACILITY|20220527120512||ORU^R01|MSGID12345|P|2.4\rOBX|1|NM|GLU^Glucose||100|mg/dL||N|||F|||20220527120512\r"
set fhirObservation = ##class(DTL.HL7toFHIR).TransformHL7ToObservation(hl7Message)
write fhirObservation

Você precisará definir as classes EnsLib.HL7.Message e FHIR.Resource.Observation no seu ambiente da InterSystems e ter as permissões apropriadas para executar o código COS.

Essa é provavelmente a resposta mais eficaz e completa que poderíamos esperar em cerca de 25 segundos. Não é?

(_Observação: a amostra COS acima não é perfeitamente precisa. É só uma estrutura boilerplate e precisa de mais ajustes para implementações reais. Como @Tete.Zhang_ gentilmente indicou, a classe de mensagem HL7 do nível Ensemble usa ImportFromSting() em vez de Parse(); DocType deve ser mais específico etc. E, aparentemente, parece criar uma nova hierarquia de classe FHIR por conta própria do zero, em vez de usar a canalização FHIR STU3 integrada do HealthShare existente. Seu "raciocínio" parece seguir a resposta anterior da estrutura do Python. Ele não vai ganhar uma certificação Ensemble ou HealthShare por enquanto e tem muito a aprender com mais interações especializadas. No entanto, como uma desculpa, talvez tenhamos que perdoá-lo pelo seu primeiro teste em menos de 2 minutos até o momento. )

Agora que estamos aqui, precisamos ser justos com as outras opções amplamente usadas que também tenho gostado. Então, continuei com mais algumas perguntas e um pouco mais de fé:

Pergunta 4: Você pode fornecer uma amostra de transformação do HL7 V2 par FHIR Stu3 no Orion Rhapsody?

ChatGPT:

Com certeza! Aqui está um exemplo de como transformar uma mensagem HL7 V2 para um recurso FHIR STU3 Observation no Orion Rhapsody:

Primeiro, crie um novo canal do Rhapsody e adicione um componente do Conector HL7 para receber a mensagem HL7 V2 de entrada.
Adicione um novo componente de Transformação de Dados ao canal e o configure para usar um script personalizado.
No componente de Transformação de Dados, adicione o seguinte script para transformar a mensagem HL7 V2 em um recurso FHIR STU3 Observation:

function transform(msg) {

    var hl7 = Packages.ca.uhn.hl7v2.model.v24.message.ORU_R01(msg.getRawData());

    var observation = new Packages.org.hl7.fhir.dstu3.model.Observation();
    observation.setStatus(Packages.org.hl7.fhir.dstu3.model.Observation.ObservationStatus.FINAL);

    var codeableConcept = new Packages.org.hl7.fhir.dstu3.model.CodeableConcept();
    var coding = new Packages.org.hl7.fhir.dstu3.model.Coding();
    coding.setSystem("http://loinc.org");
    coding.setCode(hl7.getRESPONSE().getORDER_OBSERVATION()[0].getOBR().getUniversalServiceIdentifier().getIdentifier().getValue());
    coding.setDisplay(hl7.getRESPONSE().getORDER_OBSERVATION()[0].getOBR().getUniversalServiceIdentifier().getText().getValue());
    codeableConcept.addCoding(coding);
    observation.setCode(codeableConcept);

    var quantity = new Packages.org.hl7.fhir.dstu3.model.Quantity();
    quantity.setValue(hl7.getRESPONSE().getORDER_OBSERVATION()[0].getOBSERVATION()[0].getOBX().getObservationValue()[0].getValue().getValue());
    quantity.setUnit(hl7.getRESPONSE().getORDER_OBSERVATION()[0].getOBSERVATION()[0].getOBX().getUnits().getText().getValue());
    observation.setValue(quantity);

    var reference = new Packages.org.hl7.fhir.dstu3.model.Reference();
    reference.setReference("Patient/" + hl7.getPATIENT_RESULT().getPATIENT().getPid3_PatientIdentifierList()[0].getID().getValue());
    observation.setSubject(reference);

    return JSON.stringify(observation);
}

Salve o script e teste a transformação enviando uma mensagem HL7 V2 para o canal. O recurso FHIR STU3 Observation transformado deve ser gerado pelo componente de Transformação de Dados no formato JSON.

Esse script usa as bibliotecas HAPI FHIR e HAPI HL7 v2, que estão incluídas no Orion Rhapsody. Ele começa analisando a mensagem HL7 V2 de entrada usando a biblioteca HAPI HL7.

Em seguida, o script cria um novo recurso FHIR STU3 Observation e define os elementos status, code, value e subject com base nos valores correspondentes na mensagem HL7.

Por fim, o script serializa o recurso FHIR como JSON e o retorna.

Esse é só um exemplo simples e talvez não funcione para todos os tipos de mensagem HL7 V2 ou recursos FHIR. Você pode precisar modificar o script para lidar com os diferentes tipos de mensagens ou mapear campos adicionais para o recurso FHIR.

Pergunta 5 Você pode criar uma amostra de transformação convertendo HL7 v2.4 em FHIR R4 no mecanismo de integração Mirth?

ChatGPT:

Com certeza! Aqui está um exemplo de como transformar uma mensagem HL7 V2.4 para um recurso FHIR R4 Observation no Mirth:

Primeiro, crie um novo canal do Mirth e adicione um conector de origem Listener HL7v2 para receber a mensagem HL7 V2 de entrada.
Adicione um novo conector de destino do JavaScript Writer ao canal e o configure para usar um script personalizado.
No conector JavaScript Writer, adicione o seguinte script para transformar a mensagem HL7 V2 em um recurso FHIR R4 Observation:

var hl7msg = msg['HL7v2 Message'].toString(); // get the HL7 V2 message
var hl7data = Packages.ca.uhn.hl7v2.parser.Parser.parse(hl7msg); // parse the message with the HAPI HL7 parser
// extract values from the HL7 message and create the FHIR resource
var obs = new Packages.org.hl7.fhir.r4.model.Observation();
obs.setStatus(Packages.org.hl7.fhir.r4.model.Observation.ObservationStatus.FINAL);

var code = new Packages.org.hl7.fhir.r4.model.CodeableConcept();
code.addCoding()
  .setSystem("http://loinc.org")
  .setCode(hl7data.get("OBR-4-1").getValue())
  .setDisplay(hl7data.get("OBR-4-2").getValue());
obs.setCode(code);

var value = new Packages.org.hl7.fhir.r4.model.Quantity();
value.setValue(hl7data.get("OBX-5-1").getValue());
value.setUnit(hl7data.get("OBX-6").getValue());
obs.setValue(value);

var subject = new Packages.org.hl7.fhir.r4.model.Reference();
subject.setReference("Patient/" + hl7data.get("PID-3-1").getValue());
obs.setSubject(subject);

// output the FHIR resource as JSON
var json = org.hl7.fhir.r4.formats.JsonParser().setPrettyPrint(true).encodeResourceToString(obs);
return json;

Salve o script e teste a transformação enviando uma mensagem HL7 V2 para o canal. O recurso FHIR R4 Observation transformado deve ser gerado pelo conector JavaScript Writer no formato JSON.

Esse script usa as bibliotecas HAPI FHIR e HAPI HL7 v2, que estão incluídas no Mirth. Ele começa extraindo a mensagem HL7 V2 do objeto de mensagem do Mirth e a analisando com o parser HAPI HL7.

Em seguida, o script cria um novo recurso FHIR R4 Observation e define os elementos status, code, value e subject com base nos valores correspondentes na mensagem HL7.

Por fim, o script serializa o recurso FHIR como JSON e o retorna.

Conclusões?

Não tenho mais nenhuma conclusão ou próximas etapas, já que até minha imaginação não consegue acompanhar seus saltos. Parece que há poucas opções para mim agora: posso gastar tempo buscando os estilos de codificação imperfeitos ou repensar os problemas que eu ainda tiver em mais algumas semanas. Preciso pensar com mais cuidado do que nunca sobre o potencial disso. :)

Brincadeiras à parte, estou gostando de postar neste fórum (graças aos anfitriões), mas outro pensamento que me vem à mente é se isso poderia ser um facilitador importante para algum player de nicho competitivo entrar no mercado de consumo em massa, não é? Por vários motivos, para se sentir realmente confortável com algumas linguagens de codificação e scripts, isso costumava levar anos, mas o cenário está mudando. O ChatGPT oferece documentação, instruções e amostras bem compostas e, nos próximos meses ou anos, talvez consiga também fabricar automaticamente as ferramentas de engenharia da sua escolha. Ele parece ser capaz de nivelar o campo nas "linguagens" e, no final, o lado não funcional de recursos, como o desempenho, e as qualidades do serviço pareceriam mais notáveis.

Ir para o posto original escrito por @Zhong Li