Add files using upload-large-folder tool

code/RL_model/models/RL_model_only_subclaim_test/global_step_60/actor/huggingface/added_tokens.json

@@ -0,0 +1,28 @@
+{
+  "</think>": 151668,
+  "</tool_call>": 151658,
+  "</tool_response>": 151666,
+  "<think>": 151667,
+  "<tool_call>": 151657,
+  "<tool_response>": 151665,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

code/RL_model/models/RL_model_only_subclaim_test/global_step_60/actor/huggingface/chat_template.jinja

@@ -0,0 +1,61 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

code/RL_model/models/RL_model_only_subclaim_test/global_step_60/actor/huggingface/config.json

@@ -0,0 +1,68 @@
+{
+  "architectures": [
+    "Qwen3ForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "dtype": "float32",
+  "eos_token_id": 151645,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 2560,
+  "initializer_range": 0.02,
+  "intermediate_size": 9728,
+  "layer_types": [
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention"
+  ],
+  "max_position_embeddings": 262144,
+  "max_window_layers": 36,
+  "model_type": "qwen3",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 36,
+  "num_key_value_heads": 8,
+  "pad_token_id": 151643,
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 5000000,
+  "sliding_window": null,
+  "tie_word_embeddings": true,
+  "transformers_version": "4.56.1",
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 151936
+}

code/RL_model/models/RL_model_only_subclaim_test/global_step_60/actor/huggingface/special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

code/RL_model/models/converted_model/v1/added_tokens.json

@@ -0,0 +1,28 @@
+{
+  "</think>": 151668,
+  "</tool_call>": 151658,
+  "</tool_response>": 151666,
+  "<think>": 151667,
+  "<tool_call>": 151657,
+  "<tool_response>": 151665,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

code/RL_model/models/converted_model/v1/chat_template.jinja

@@ -0,0 +1,61 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

code/RL_model/models/converted_model/v1/config.json

@@ -0,0 +1,68 @@
+{
+  "architectures": [
+    "Qwen3ForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "dtype": "bfloat16",
+  "eos_token_id": 151645,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 2560,
+  "initializer_range": 0.02,
+  "intermediate_size": 9728,
+  "layer_types": [
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention"
+  ],
+  "max_position_embeddings": 262144,
+  "max_window_layers": 36,
+  "model_type": "qwen3",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 36,
+  "num_key_value_heads": 8,
+  "pad_token_id": 151643,
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 5000000,
+  "sliding_window": null,
+  "tie_word_embeddings": true,
+  "transformers_version": "4.56.1",
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 151936
+}

code/RL_model/models/converted_model/v1/generation_config.json

@@ -0,0 +1,13 @@
+{
+  "bos_token_id": 151643,
+  "do_sample": true,
+  "eos_token_id": [
+    151645,
+    151643
+  ],
+  "pad_token_id": 151643,
+  "temperature": 0.7,
+  "top_k": 20,
+  "top_p": 0.8,
+  "transformers_version": "4.56.1"
+}

code/RL_model/models/converted_model/v1/model.safetensors.index.json

@@ -0,0 +1,407 @@
+{
+  "metadata": {
+    "total_parameters": 4411424256,
+    "total_size": 8822848512
+  },
+  "weight_map": {
+    "lm_head.weight": "model-00001-of-00002.safetensors",
+    "model.embed_tokens.weight": "model-00001-of-00002.safetensors",
+    "model.layers.0.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.0.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.0.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.0.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.0.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.0.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.0.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.0.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.0.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.0.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.0.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.1.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.1.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.1.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.1.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.1.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.1.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.1.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.1.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.1.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.1.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.1.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.10.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.10.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.10.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.10.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.10.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.10.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.10.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.10.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.10.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.10.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.10.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.11.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.11.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.11.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.11.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.11.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.11.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.11.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.11.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.11.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.11.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.11.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.12.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.12.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.12.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.12.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.12.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.12.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.12.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.12.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.12.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.12.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.12.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.13.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.13.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.13.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.13.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.13.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.13.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.13.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.13.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.13.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.13.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.13.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.14.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.14.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.14.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.15.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.15.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.15.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.15.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.15.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.15.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.15.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.15.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.15.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.15.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.15.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.16.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.16.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.16.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.16.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.16.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.16.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.16.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.16.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.16.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.16.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.16.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.17.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.17.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.17.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.17.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.17.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.17.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.17.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.17.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.17.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.17.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.17.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.18.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.18.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.19.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.19.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.19.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.19.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.19.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.19.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.19.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.19.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.19.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.19.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.19.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.2.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.2.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.2.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.2.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.2.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.2.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.2.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.2.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.2.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.2.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.2.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.20.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.20.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.20.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.20.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.20.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.20.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.20.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.20.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.20.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.20.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.20.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.21.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.21.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.21.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.21.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.21.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.21.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.21.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.21.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.21.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.21.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.21.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.22.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.22.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.22.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.22.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.22.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.22.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.22.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.22.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.22.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.22.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.22.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.23.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.23.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.23.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.23.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.23.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.23.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.23.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.23.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.23.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.23.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.23.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.24.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.24.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.24.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.24.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.24.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.24.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.24.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.24.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.24.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.24.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.24.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.25.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.25.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.25.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.25.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.25.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.25.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.25.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.25.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.25.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.25.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.25.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.26.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.26.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.26.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.26.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.26.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.26.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.26.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.26.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.26.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.26.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.26.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.27.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.27.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.27.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.27.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.27.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.27.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.27.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.27.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.27.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.27.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.27.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.28.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.28.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.28.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.28.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.28.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.28.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.28.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.28.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.28.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.28.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.28.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.29.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.29.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.29.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.29.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.29.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.29.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.29.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.29.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.29.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.29.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.29.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.3.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.3.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.3.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.3.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.3.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.3.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.3.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.3.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.3.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.3.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.3.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.30.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.30.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.30.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.30.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.30.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.30.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.30.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.30.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.30.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.30.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.30.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.31.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.31.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.31.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.31.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.31.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.31.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.31.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.31.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.31.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.31.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.31.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.32.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.32.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.32.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.32.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.32.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.32.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.32.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.32.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.32.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.32.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.32.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.33.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.33.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.33.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.33.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.33.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.33.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.33.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.33.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.33.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.33.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.33.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.34.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.35.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.35.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.35.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.35.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.35.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.35.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.35.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.35.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.35.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.35.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.35.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.4.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.4.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.4.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.4.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.4.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.4.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.4.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.4.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.4.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.4.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.4.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.5.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.5.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.5.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.5.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.5.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.5.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.5.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.5.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.5.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.5.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.5.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.6.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.6.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.6.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.6.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.6.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.6.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.6.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.6.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.6.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.6.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.6.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.7.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.7.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.7.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.7.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.7.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.7.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.7.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.7.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.7.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.7.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.7.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.8.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.8.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.8.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.9.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.9.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.9.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.9.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.layers.9.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.9.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.layers.9.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.9.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.9.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.layers.9.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.layers.9.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.norm.weight": "model-00001-of-00002.safetensors"
+  }
+}

code/RL_model/models/converted_model/v1/special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

code/RL_model/models/converted_model/v1/tokenizer_config.json

@@ -0,0 +1,239 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151665": {
+      "content": "<tool_response>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151666": {
+      "content": "</tool_response>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151667": {
+      "content": "<think>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151668": {
+      "content": "</think>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 1010000,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

code/finetune-inference/old/api_call.py

@@ -0,0 +1,125 @@
+from openai import OpenAI
+import re
+
+client = OpenAI()
+
+# --- Fernández Huerta formula ---
+def fernandez_huerta_score(text: str) -> float:
+    sentences = re.split(r'[.!?]+', text)
+    sentences = [s.strip() for s in sentences if s.strip()]
+    n_sentences = len(sentences) if sentences else 1
+
+    words = text.split()
+    n_words = len(words) if words else 1
+
+    vowels = "aeiouáéíóúüAEIOUÁÉÍÓÚÜ"
+    n_syllables = sum(sum(1 for ch in word if ch in vowels) for word in words)
+
+    return 206.84 - 0.60 * (n_syllables / n_words * 100) - 1.02 * (n_words / n_sentences)
+
+
+# --- Prompt templates for each label ---
+LABEL_PROMPTS = {
+    "easy": """Texto original:
+{original_text}
+
+Reescribe el texto en un lenguaje muy simple, frases cortas y vocabulario fácil, adecuado para estudiantes de 5º a 7º grado.
+El resultado debe seguir lógicamente el texto original y mantener el mismo significado.
+No añadas información nueva, no elimines detalles importantes ni cambies los hechos.
+""",
+    "intermediate": """Texto original:
+{original_text}
+
+Reescribe el texto con una complejidad moderada, frases más largas y vocabulario variado, adecuado para secundaria/bachillerato (8º a 12º grado).
+El resultado debe seguir lógicamente el texto original y mantener el mismo significado.
+No añadas información nueva, no elimines detalles importantes ni cambies los hechos.
+""",
+    "hard": """Texto original:
+{original_text}
+
+Reescribe el texto con lenguaje técnico, detallado y especializado, adecuado para universidad o profesionales.
+El resultado debe seguir lógicamente el texto original y mantener el mismo significado.
+No añadas información nueva, no elimines detalles importantes ni cambies los hechos.
+"""
+}
+
+
+# --- Generate text for a label ---
+def generate_label_text(original_text: str, label: str) -> str:
+    prompt = LABEL_PROMPTS[label].format(original_text=original_text)
+    response = client.chat.completions.create(
+        model="gpt-5-mini",  # first try with mini
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content.strip()
+
+
+# --- Regenerate if FH score is out of range ---
+def regenerate_label_text(original_text: str, old_text: str, label: str, target_range: tuple) -> str:
+    prompt = f"""Texto original:
+{original_text}
+
+Texto generado (necesita ajuste):
+{old_text}
+
+El texto anterior no cumple con el rango de legibilidad {target_range}.
+Reescribe nuevamente el texto en el nivel "{label}", ajustando la dificultad 
+para que el puntaje de Fernández Huerta quede dentro del rango {target_range}.
+El resultado debe seguir lógicamente el texto original y mantener el mismo significado.
+No añadas información nueva, no elimines detalles importantes ni cambies los hechos.
+"""
+    response = client.chat.completions.create(
+        model="gpt-5",  # use stronger model for regeneration
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content.strip()
+
+
+
+# --- Target ranges for FH ---
+RANGES = {
+    "easy": (70, 100),
+    "intermediate": (50, 70),
+    "hard": (0, 50)
+}
+
+
+# --- Full pipeline for one topic ---
+def generate_synthetic_data(original_text: str, original_language: str, topic: str, data_id: int):
+    results = {
+        "id": data_id,
+        "original_text_language": original_language,
+        "source_topic": topic,
+        "readability_versions": {}
+    }
+
+    for label, target_range in RANGES.items():
+        # Step 1: generate
+        text = generate_label_text(original_text, label)
+
+        # Step 2: check FH score
+        score = fernandez_huerta_score(text)
+        if not (target_range[0] <= score <= target_range[1]):
+            text = regenerate_label_text(original_text, text, label, target_range)
+
+
+        # Step 4: save
+        results["readability_versions"][label] = {
+            "readability_level": label,
+            "fernandez_huerta_range": f"{target_range[0]}-{target_range[1]}",
+            "target_audience": (
+                "Estudiantes de primaria/media (5º a 7º grado)" if label == "easy" else
+                "Secundaria/Bachillerato (8º a 12º grado)" if label == "intermediate" else
+                "Profesionales / Universidad o posgrado"
+            ),
+            "text": text
+        }
+
+    return results
+
+
+# --- Example usage ---
+if __name__ == "__main__":
+    original_text = "Se diagnosticó osteoartritis bilateral en un paciente de 61 años con dolor en la ingle."
+    data = generate_synthetic_data(original_text, "es", "Osteoartritis de cadera", 1)
+    print(data)

code/finetune-inference/old/api_call_vllm.py

@@ -0,0 +1,135 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+# Ensure this matches the model path used in your run_vllm.sh script
+MODEL_NAME = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims_BF16_merged"
+API_URL = "http://localhost:8015/v1"
+API_KEY = "EMPTY"  # vLLM requires a key, but it can be anything if not set on server
+
+# Initialize Client
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    prompt = f"""
+You are an expert medical annotator. Your task is to extract granular, factual subclaims from medical text.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+Instructions:
+1. Read the provided medical text.
+2. Break it into clear, objective, atomic subclaims.
+3. Each subclaim must come directly from the text.
+4. Do not add, guess, or infer information.
+5. Each subclaim should be short, specific, and verifiable.
+6. Return ONLY a Python-style list of strings.
+Medical Text:
+{medical_text}
+Return your output in JSON list format, like:
+[
+  "subclaim 1",
+  "subclaim 2",
+  ...
+]
+"""
+    return prompt
+
+# -----------------------------
+#  INFERENCE FUNCTION (vLLM)
+# -----------------------------
+def infer_subclaims(medical_text: str, temperature: float = 0.2) -> str:
+    """Sends prompt to vLLM server and returns generated text."""
+    
+    # 1. Prepare the prompt
+    final_prompt = extraction_prompt(medical_text)
+    
+    # 2. Call the vLLM Server via OpenAI API
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "user", "content": final_prompt}
+            ],
+            max_tokens=1000,       # Limit generation length
+            temperature=temperature,
+            top_p=0.9,
+            frequency_penalty=0.0,
+            presence_penalty=0.0,
+        )
+        res = response.choices[0].message.content.strip()
+        res=res.split("</think>")[-1].strip()
+        return res
+    except Exception as e:
+        print(f"Error during API call: {e}")
+        return None
+
+# -----------------------------
+#  MAIN EXECUTION
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, required=True,
+                        help="Path to the input JSON file containing medical texts.")
+    args = parser.parse_args()
+
+    INPUT_FILE = args.input_file
+    file_name = os.path.basename(INPUT_FILE).split(".json")[0]
+    
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"extracted_subclaims_{file_name}.json")
+
+    # Load input dataset
+    with open(INPUT_FILE, "r") as f:
+        data = json.load(f)
+
+    # Load existing results (resume mode)
+    result = []
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r") as f:
+            try:
+                result = json.load(f)
+            except json.JSONDecodeError:
+                result = []
+    
+    existing_ids = {item["id"] for item in result}
+
+    print(f"Starting inference on {len(data)} items using vLLM server...")
+    save=False
+    # --------------------------------------------------------
+    # PROCESS EACH MEDICAL TEXT
+    # --------------------------------------------------------
+    for item in tqdm.tqdm(data):
+        if item["id"] in existing_ids:
+            continue
+
+        medical_text = item.get("fulltext", "")
+        
+        # Call the vLLM inference function
+        extracted = infer_subclaims(medical_text)
+
+        result.append({
+            "id": item["id"],
+            "medical_text": medical_text,
+            "subclaims": extracted,
+            "summary": item.get("summary", "")
+        })
+
+        # Save every 20 entries
+        if len(result) % 20 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                if save:
+                    json.dump(result, f, indent=4, ensure_ascii=False)
+
+    # Final save
+    with open(OUTPUT_FILE, "w") as f:
+        if save:
+            json.dump(result, f, indent=4, ensure_ascii=False)
+
+    print(f"Extraction completed. Saved to {OUTPUT_FILE}")

code/finetune-inference/old/attribution_reasoning.py

@@ -0,0 +1,198 @@
+import json
+import sys
+from openai import OpenAI
+import ast,os
+# ===========================
+# CONFIGURATION
+# ===========================
+MODEL_NAME = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-attribution_resonability_check_8kCtx_v1_BF16_merged"
+VLLM_API_URL = "http://localhost:8004/v1"
+VLLM_API_KEY = "EMPTY" 
+
+# Initialize Client
+client = OpenAI(
+    base_url=VLLM_API_URL,
+    api_key=VLLM_API_KEY,
+)
+
+# ===========================
+# INFERENCE FUNCTION
+# ===========================
+def infer_reasonableness(
+    fulltext: str,
+    generated_summary: str,
+    readability_level: str,
+    subclaim_text: str,
+    result: int,
+):
+    """
+    Predict reasonableness using the local vLLM server.
+    No error handling: validation or connection errors will raise exceptions.
+    """
+
+    # ---- Build inference prompt ----
+    prompt = f"""
+### **SYSTEM / ROLE INSTRUCTION**
+
+You are a **medical factuality and attribution evaluator**.
+You will assess whether the **unsupported subclaim** in a generated summary (when `"result": 0"`) is a *reasonable addition* given the readability level (*easy / intermediate / hard*).
+
+The goal is to decide whether this **extra piece of information** is an acceptable simplification or a *hallucination* that reduces factual faithfulness.
+
+---
+
+### **READABILITY & ATTRIBUTION GUIDELINES**
+
+| Level | Audience | Linguistic & Stylistic Profile | Content Goal | Allowable Additions |
+| :-- | :-- | :-- | :-- | :-- |
+| **Easy (FH 70–100, grade 5–7)** | General public; early secondary readers | Short, direct sentences using common vocabulary and concrete ideas. Avoid subordinate clauses and technical terms. Tone should be explanatory, lively, and highly accessible. | Simplify and clarify events and outcomes without introducing technical or diagnostic details. | General background context or plain-language explanations are acceptable; **no new facts, data, or inferred medical claims.** |
+| **Intermediate (FH 50–69, grade 8–12)** | Educated layperson / medical student | Moderate sentence length and complexity. Vocabulary suitable for high-school or introductory science readers. May include limited domain terms with brief clarification. | Present essential medical content with clear logic and limited detail, ensuring readability for non-experts. | Brief clarifications, definitions, or causal links consistent with the source are allowed; **avoid speculative or unconfirmed data.** |
+| **Hard (FH 0–49, university / professional)** | Medical professionals / technical audience | Long, multi-clause sentences; formal academic tone. Incorporate precise domain vocabulary, causal and analytical connectors (e.g., *por consiguiente*, *sin embargo*, *en virtud de*, *dado que*), at least one definition, one process description, and one statement of implications or challenges. | Preserve full factual accuracy, diagnostic precision, and interpretive nuance expected in professional discourse. | Additions are **not permitted**; every statement must be directly supported by the reference text. Parenthetical clarifications or relative clauses may be used for cohesion, not new content. |
+
+---
+
+### **Input**
+
+```
+Readability Level: {readability_level}
+
+Reference Full Text:
+{fulltext}
+
+Generated Summary:
+{generated_summary}
+
+Subclaim: "{subclaim_text}"
+Result: {result}   # 1 = supported (included), 0 = unsupported
+```
+
+---
+
+### **TASK INSTRUCTIONS**
+
+If `"result": 0"`, judge whether including this subclaim is **reasonable** for the given readability level.  
+Choose one of: `"reasonable addition"`, `"unnecessary but harmless"`, `"misleading / hallucinated"`.  
+Provide a **1–2 sentence justification** describing your reasoning.
+
+---
+
+### **Output Format**
+
+Return structured JSON:
+
+```json
+{{
+  "evaluation": {{
+      "reasonableness": "<reasonable | partially_reasonable | unreasonable>",
+      "justification": "<short explanation>"
+  }}
+}}
+```
+""".strip()
+
+    messages = [{"role": "user", "content": prompt}]
+
+    # ---- Call vLLM Server ----
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=messages,
+        temperature=0.2,
+        max_tokens=200,
+        top_p=0.8,
+    )
+
+    output_text = response.choices[0].message.content
+
+    # ---- Clean Output (Handle Thinking & Markdown) ----
+    try:
+        if "</think>" in output_text:
+            output_text = output_text.split("</think>")[1]
+        
+        clean_text = output_text.strip().replace("```json", "").replace("```", "").strip()
+        # import ipdb; ipdb.set_trace()
+        t=ast.literal_eval(clean_text)
+
+        # ---- Parse JSON (Will raise JSONDecodeError if invalid) ----
+        return t
+    except Exception as e:
+        return output_text
+
+
+# ===========================
+# MAIN EXECUTION
+# ===========================
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_path", type=str, required=True,
+                        help="Path to the JSON file containing evaluation data.")
+    args = parser.parse_args()
+    data_path = args.data_path
+    # data_path = '/home/mshahidul/readctrl/data/concise_complete_attr_cal_v3/evaluated_metrics_0_100.json'
+    file_name=os.path.basename(data_path)
+    
+    # Open file directly (Will raise FileNotFoundError if missing)
+    with open(data_path, 'r') as f:
+        dataset = json.load(f)
+        
+    # print(f"Loaded {len(dataset)} examples. Starting inference...")
+    save_path = f'/home/mshahidul/readctrl/data/attribution_reasoning_result/{file_name}'
+    os.makedirs('/home/mshahidul/readctrl/data/attribution_reasoning_result/', exist_ok=True)
+    full_results = []
+    if os.path.exists(save_path):
+        with open(save_path, 'r') as f:
+            full_results = json.load(f)
+
+    import tqdm
+    for item in tqdm.tqdm(dataset):
+        if any(d['id'] == item['id'] for d in full_results):
+            continue  
+        fulltext = item['fulltext']
+        temp2={}
+        for label in ['easy', 'intermediate', 'hard']:
+            generated_summary = item[f'{label}_text']
+            subclaim_list = item['metrics'][f'{label}']['attribution']['details']
+            temp=[]
+            for idx, subclaim in enumerate(subclaim_list):
+                
+                # Check status (assumes subclaim variable holds the status string)
+                result = 1 if subclaim['label'] == 'supported' else 0
+                
+                if result ==0:
+                    output = infer_reasonableness(
+                                fulltext=fulltext,
+                                generated_summary=generated_summary,
+                                readability_level=label,
+                                subclaim_text=subclaim['subclaim'],
+                                result=result,
+                        )
+                        
+                    temp.append({
+                                'subclaim': subclaim['subclaim'],
+                                'output': output
+                            })
+                else:
+                    temp.append({
+                                'subclaim': subclaim['subclaim'],
+                                'output': {
+                                    'reasonableness': 'reasonable',
+                                    'justification': 'The subclaim is included in the generated summary, hence it is reasonable.'
+                                }
+                            })
+
+            temp2[label] = {
+                'results': temp
+            }
+        full_results.append({
+            'id': item['id'],
+            'completeness': temp2
+        })
+        if len(full_results) % 10 == 0:
+            with open(save_path, 'w') as f:
+                json.dump(full_results, f, indent=2, ensure_ascii=False)
+
+    with open(save_path, 'w') as f:
+        json.dump(full_results, f, indent=2, ensure_ascii=False)
+
+                
+                

code/finetune-inference/old/completeness_conciseness_attribution_cal.py

@@ -0,0 +1,151 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+import torch
+from unsloth import FastLanguageModel
+import json
+
+# Optional: wrap model/tokenizer in a singleton pattern for repeated use
+_model_cache = {"model": None, "tokenizer": None}
+
+def load_finetuned_model(model_path: str):
+    """Load and cache your fine‑tuned model + tokenizer."""
+    if _model_cache["model"] is not None:
+        return _model_cache["model"], _model_cache["tokenizer"]
+
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_path,
+        max_seq_length=4092,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+    _model_cache["model"], _model_cache["tokenizer"] = model, tokenizer
+    return model, tokenizer
+
+
+def infer_subclaim(text: str, subclaim: str, model_path: str = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-verifier_lora_nonreasoning", cuda_device: str = "0") -> str:
+    """
+    Given a medical text and a subclaim, returns '1' if the text supports the subclaim, otherwise '0'.
+    """
+    model, tokenizer = load_finetuned_model(model_path)
+
+    # Build prompt (the same structure you trained on)
+    prompt = f"""
+    Given the following medical text and subclaim, decide if the text supports the subclaim.
+    Text: {text}
+    Subclaim: {subclaim}
+    Respond only with 1 if the text supports the subclaim, otherwise 0.
+    """.strip()
+
+    messages = [{"role": "user", "content": prompt + "\n"}]
+
+    chat_text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,
+    )
+
+    inputs = tokenizer(chat_text, return_tensors="pt").to("cuda")
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=10,
+            temperature=0.1,
+            top_p=0.8,
+            top_k=5,
+        )
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
+    return output_text.split("</think>")[1].strip()
+
+if __name__ == "__main__":
+    # example_text = (
+    #     "Una niña nacida a las 34 semanas de gestación precisó intubación y ventilación al nacer..."
+    # )
+    # example_subclaim = "La paciente es una recién nacida prematura."
+    
+    def process_completeness(example,version):
+        example_text = example["readability_versions"][version]['text']
+        example_subclaims = example['ref_summary']["subclaims"]
+        # print("Input text:", example_text)
+        res=[]
+        total=0
+        correct=0
+        for example_subclaim in example_subclaims:
+            result = infer_subclaim(example_text, example_subclaim)
+            if "1" in result:
+                correct+=1
+                total+=1
+            elif "0" in result:
+                total+=1
+            res.append({
+                "subclaim": example_subclaim,
+                "result": result
+            })
+        return {"metric": "completeness", "version": version, "input_text": example_text, "results": res, "total": total, "correct": correct, "accuracy": (correct/total)*100 if total>0 else 0}
+
+    def process_conciseness(example, version):
+        example_text = example["ref_summary"]['text']
+        example_subclaims = example["readability_versions"][version]["subclaims"]
+        # print("Input text:", example_text)
+        res=[]
+        total=0
+        correct=0
+        for example_subclaim in example_subclaims:
+            result = infer_subclaim(example_text, example_subclaim)
+
+            if "1" in result:
+                correct+=1
+                total+=1
+            elif "0" in result:
+                total+=1
+            res.append({
+                "subclaim": example_subclaim,
+                "result": result
+            })
+        return {"metric": "conciseness", "version": version, "input_text": example_text, "results": res, "total": total, "correct": correct, "accuracy": (correct/total)*100 if total>0 else 0}
+    def process_attribution(example, version):
+        example_text = example['full_text']
+        example_subclaims = example["readability_versions"][version]["subclaims"]
+        # print("Input text:", example_text)
+        res=[]
+        total=0
+        correct=0
+        for example_subclaim in example_subclaims:
+            result = infer_subclaim(example_text, example_subclaim)
+            if "1" in result:
+                correct+=1
+                total+=1
+            elif "0" in result:
+                total+=1
+            res.append({
+                "subclaim": example_subclaim,
+                "result": result
+            })
+        return {"metric": "attribution", "version": version, "input_text": example_text, "results": res, "total": total, "correct": correct, "accuracy": (correct/total)*100 if total>0 else 0}
+    with open("/home/mshahidul/readctrl/data/training_data_subclaim_verifier/synthetic_data_es_subclaims_100.json", "r", encoding="utf-8") as f:
+        data = json.load(f)
+    import tqdm
+    full_data_results = []
+    save_path = "/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json"
+    for item in tqdm.tqdm(data):
+        print(f"Processing item ID: {item['id']}")
+        for version in ["easy", "intermediate", "hard"]:
+            completeness=process_completeness(item,version)
+            conciseness=process_conciseness(item,version)
+            attribution=process_attribution(item,version)
+            full_data_results.append({
+                "id": item["id"],
+                "version": version,
+                "completeness": completeness,
+                "conciseness": conciseness,
+                "attribution": attribution
+            })
+            if len(full_data_results)%5==0:
+                with open(save_path, "w", encoding="utf-8") as f:
+                    json.dump(full_data_results, f, indent=4, ensure_ascii=False)
+    with open(save_path, "w", encoding="utf-8") as f:
+        json.dump(full_data_results, f, indent=4, ensure_ascii=False)

code/finetune-inference/old/completeness_reasoning_v1.py

@@ -0,0 +1,186 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "4"
+import torch
+from unsloth import FastLanguageModel
+import json
+
+# ===========================
+# GPU SETTINGS
+# ===========================
+
+
+# ===========================
+# MODEL LOADING (CACHED)
+# ===========================
+_model_cache = {"model": None, "tokenizer": None}
+
+def load_finetuned_model(model_path: str):
+    """Load and cache the fine-tuned model + tokenizer."""
+    if _model_cache["model"] is not None:
+        return _model_cache["model"], _model_cache["tokenizer"]
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_path,
+        max_seq_length=4096,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+    _model_cache["model"], _model_cache["tokenizer"] = model, tokenizer
+    return model, tokenizer
+
+
+# ===========================
+# INFERENCE FUNCTION
+# ===========================
+def infer_reasonableness(
+    reference_summary: str,
+    generated_summary: str,
+    readability_level: str,
+    subclaim_text: str,
+    result: int,
+    model_path: str = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-completeness_resonability_check_v2",
+):
+    """
+    Given the reference summary, generated summary, readability level, subclaim, and its result (0/1),
+    predict reasonableness: reasonable / partially_reasonable / unreasonable, plus justification.
+    """
+    model, tokenizer = load_finetuned_model(model_path)
+
+    # ---- Build inference prompt (same structure as training) ----
+    prompt = f"""
+You are an impartial medical summarization evaluator.
+
+Goal:
+Decide whether the inclusion or omission of ONE specific subclaim from the reference summary is *reasonable*, given the readability level of the generated summary.
+
+Readability Criteria:
+- Easy: for non-medical readers; emphasize main story and outcomes; omit numerical data, anatomy, and test details.
+- Intermediate: for general educated readers; keep main findings but simplify phrasing.
+- Hard: for clinical or technical readers; maintain diagnostic accuracy and essential quantitative or anatomic content.
+
+Judging rules:
+* Base your decision strictly on what appears in the generated summary.
+* If result = 0 (subclaim omitted) and the omitted detail is clearly technical or numerical for the given level, choose "reasonable".
+* If result = 0 and the subclaim is essential to the main story, choose "unreasonable".
+* Stay consistent between `result`, justification, and readability level.
+
+### Inputs
+Readability Level: {readability_level}
+Reference Summary: {reference_summary}
+Generated Summary: {generated_summary}
+Subclaim: "{subclaim_text}"
+Result: {result}   # 1 = supported (included), 0 = omitted
+
+### Task
+Respond **only** with the following JSON object:
+
+{{
+  "reasonableness": "<reasonable | partially_reasonable | unreasonable>",
+  "justification": "<short clear explanation>"
+}}
+""".strip()
+
+    messages = [{"role": "user", "content": prompt + "\n"}]
+
+    chat_text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,  # important for Unsloth chat template
+    )
+
+    inputs = tokenizer(chat_text, return_tensors="pt").to("cuda")
+
+    # ---- Generate output ----
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=150,
+            temperature=0.2,
+            top_p=0.8,
+            top_k=5,
+            do_sample=False,
+        )
+
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
+    output_text = output_text.split("</think>")[1].strip()
+    # ---- Extract model JSON output ----
+    try:
+        parsed = json.loads(output_text)
+    except Exception:
+        # print("Failed to parse JSON from model output. Returning raw text.\n\n")
+        parsed = output_text
+    return parsed
+
+
+# ===========================
+# EXAMPLE USAGE
+# ===========================
+if __name__ == "__main__":
+    # reference_summary = "Una niña nacida a las 34 semanas de gestación precisó intubación..."
+    # generated_summary = "Esta es la historia de una niña que nació antes de tiempo, a las 34 semanas..."
+    # subclaim_text = "La paciente presentaba hiperinsulinismo en el período neonatal."
+    # readability_level = "easy"
+    # result = 0  # omitted
+    import json
+    with open('/home/mshahidul/readctrl/data/testing_data_gs/multiclinsum_gs_train_es.json', 'r') as f:
+        multiclinsum_gs_train_es_data = json.load(f)
+    ref_summaries={}
+    fulltexts={}
+    for item in multiclinsum_gs_train_es_data:
+        ref_summaries[item['id']]=item['summary']
+        fulltexts[item['id']]=item['fulltext']
+    
+    generated_summaries = {}
+    with open('/home/mshahidul/readctrl/data/hand_create_gpt5_other_model/synthetic_data_es_raw_592.json', 'r') as f:
+        synthetic_data_es_raw_592 = json.load(f)
+    for item in synthetic_data_es_raw_592:
+        for version in ['easy', 'intermediate', 'hard']:
+            generated_summaries[(item['id'], version)] = item['readability_versions'][version]['text']
+    # /home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json
+    with open("/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json", 'r') as f:
+        qwen3_32B_results = json.load(f)
+    full_res = []
+    save_path = "/home/mshahidul/readctrl/results/dataset_quality_check/completeness_resonability_check_100_qwen3-32B_v3.json"
+    import tqdm
+    for idx, item in tqdm.tqdm(enumerate(qwen3_32B_results)):
+        print(f"Processing item {idx + 1}/{len(qwen3_32B_results)}")
+        reference_summary = ref_summaries[item['id']]
+        fulltext = fulltexts[item['id']]
+        generated_summary = generated_summaries[(item['id'], item['version'])]
+        temp_res = []
+        for item2 in item['completeness']['results']:
+            subclaim_text = item2['subclaim']['subclaim']
+            result = item2['result']
+            if result =="1":
+                continue
+            response = infer_reasonableness(
+                reference_summary,
+                generated_summary,
+                item['version'],
+                subclaim_text,
+                result,
+                model_path="/home/mshahidul/readctrl_model/qwen3-32B_subclaims-completeness_resonability_check",
+            )
+            temp_res.append({
+                'id':item2['subclaim']['id'],
+                "subclaim": subclaim_text,
+                "result": result,
+                "reasonableness": response
+            })
+        full_res.append({
+            "id": item['id'],
+            "version": item['version'],
+            "completeness": {
+                "results": temp_res
+            }
+        })
+        if len(full_res)%10==0:
+            with open(save_path, 'w') as f:
+                json.dump(full_res, f, indent=2, ensure_ascii=False)
+
+with open(save_path, 'w') as f:
+   json.dump(full_res, f, indent=2, ensure_ascii=False)
+

code/finetune-inference/old/completeness_reasoning_v2.py

@@ -0,0 +1,186 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "4"
+import torch
+from unsloth import FastLanguageModel
+import json
+
+# ===========================
+# GPU SETTINGS
+# ===========================
+
+
+# ===========================
+# MODEL LOADING (CACHED)
+# ===========================
+_model_cache = {"model": None, "tokenizer": None}
+
+def load_finetuned_model(model_path: str):
+    """Load and cache the fine-tuned model + tokenizer."""
+    if _model_cache["model"] is not None:
+        return _model_cache["model"], _model_cache["tokenizer"]
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_path,
+        max_seq_length=4096,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+    _model_cache["model"], _model_cache["tokenizer"] = model, tokenizer
+    return model, tokenizer
+
+
+# ===========================
+# INFERENCE FUNCTION
+# ===========================
+def infer_reasonableness(
+    reference_summary: str,
+    generated_summary: str,
+    readability_level: str,
+    subclaim_text: str,
+    result: int,
+    model_path: str = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-completeness_resonability_check_8kCtx_v3",
+):
+    """
+    Given the reference summary, generated summary, readability level, subclaim, and its result (0/1),
+    predict reasonableness: reasonable / partially_reasonable / unreasonable, plus justification.
+    """
+    model, tokenizer = load_finetuned_model(model_path)
+
+    # ---- Build inference prompt (same structure as training) ----
+    prompt = f"""
+You are an impartial medical summarization evaluator.
+
+Goal:
+Decide whether the inclusion or omission of ONE specific subclaim from the reference summary is *reasonable*, given the readability level of the generated summary.
+
+Readability Criteria:
+- Easy: for non-medical readers; emphasize main story and outcomes; omit numerical data, anatomy, and test details.
+- Intermediate: for general educated readers; keep main findings but simplify phrasing.
+- Hard: for clinical or technical readers; maintain diagnostic accuracy and essential quantitative or anatomic content.
+
+Judging rules:
+* Base your decision strictly on what appears in the generated summary.
+* If result = 0 (subclaim omitted) and the omitted detail is clearly technical or numerical for the given level, choose "reasonable".
+* If result = 0 and the subclaim is essential to the main story, choose "unreasonable".
+* Stay consistent between `result`, justification, and readability level.
+
+### Inputs
+Readability Level: {readability_level}
+Reference Summary: {reference_summary}
+Generated Summary: {generated_summary}
+Subclaim: "{subclaim_text}"
+Result: {result}   # 1 = supported (included), 0 = omitted
+
+### Task
+Respond **only** with the following JSON object:
+
+{{
+  "reasonableness": "<reasonable | partially_reasonable | unreasonable>",
+  "justification": "<short clear explanation>"
+}}
+""".strip()
+
+    messages = [{"role": "user", "content": prompt + "\n"}]
+
+    chat_text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,  # important for Unsloth chat template
+    )
+
+    inputs = tokenizer(chat_text, return_tensors="pt").to("cuda")
+
+    # ---- Generate output ----
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=150,
+            temperature=0.2,
+            top_p=0.8,
+            top_k=5,
+            do_sample=False,
+        )
+
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
+    output_text = output_text.split("</think>")[1].strip().replace("```json", "").replace("```", "")
+    # ---- Extract model JSON output ----
+    try:
+        parsed = json.loads(output_text)
+    except Exception:
+        # print("Failed to parse JSON from model output. Returning raw text.\n\n")
+        parsed = output_text
+    return parsed
+
+
+# ===========================
+# EXAMPLE USAGE
+# ===========================
+if __name__ == "__main__":
+    # reference_summary = "Una niña nacida a las 34 semanas de gestación precisó intubación..."
+    # generated_summary = "Esta es la historia de una niña que nació antes de tiempo, a las 34 semanas..."
+    # subclaim_text = "La paciente presentaba hiperinsulinismo en el período neonatal."
+    # readability_level = "easy"
+    # result = 0  # omitted
+    import json
+    with open('/home/mshahidul/readctrl/data/testing_data_gs/multiclinsum_gs_train_es.json', 'r') as f:
+        multiclinsum_gs_train_es_data = json.load(f)
+    ref_summaries={}
+    fulltexts={}
+    for item in multiclinsum_gs_train_es_data:
+        ref_summaries[item['id']]=item['summary']
+        fulltexts[item['id']]=item['fulltext']
+    
+    generated_summaries = {}
+    with open('/home/mshahidul/readctrl/data/hand_create_gpt5_other_model/synthetic_data_es_raw_592.json', 'r') as f:
+        synthetic_data_es_raw_592 = json.load(f)
+    for item in synthetic_data_es_raw_592:
+        for version in ['easy', 'intermediate', 'hard']:
+            generated_summaries[(item['id'], version)] = item['readability_versions'][version]['text']
+    # /home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json
+    with open("/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json", 'r') as f:
+        qwen3_32B_results = json.load(f)
+    full_res = []
+    save_path = "/home/mshahidul/readctrl/results/dataset_quality_check/completeness_resonability_check_100_qwen3-32B_v4.json"
+    import tqdm
+    for idx, item in tqdm.tqdm(enumerate(qwen3_32B_results)):
+        print(f"Processing item {idx + 1}/{len(qwen3_32B_results)}")
+        reference_summary = ref_summaries[item['id']]
+        fulltext = fulltexts[item['id']]
+        generated_summary = generated_summaries[(item['id'], item['version'])]
+        temp_res = []
+        for item2 in item['completeness']['results']:
+            subclaim_text = item2['subclaim']['subclaim']
+            result = item2['result']
+            if result =="1":
+                continue
+            response = infer_reasonableness(
+                reference_summary,
+                generated_summary,
+                item['version'],
+                subclaim_text,
+                result,
+                model_path="/home/mshahidul/readctrl_model/qwen3-32B_subclaims-completeness_resonability_check_8kCtx_v3",
+            )
+            temp_res.append({
+                'id':item2['subclaim']['id'],
+                "subclaim": subclaim_text,
+                "result": result,
+                "reasonableness": response
+            })
+        full_res.append({
+            "id": item['id'],
+            "version": item['version'],
+            "completeness": {
+                "results": temp_res
+            }
+        })
+        if len(full_res)%10==0:
+            with open(save_path, 'w') as f:
+                json.dump(full_res, f, indent=2, ensure_ascii=False)
+
+with open(save_path, 'w') as f:
+   json.dump(full_res, f, indent=2, ensure_ascii=False)
+

code/finetune-inference/old/completeness_reasoning_v3.py

@@ -0,0 +1,171 @@
+import json
+import sys
+from openai import OpenAI
+import ast,os
+# ===========================
+# CONFIGURATION
+# ===========================
+MODEL_NAME = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-completeness_resonability_check_8kCtx_v3_BF16_merged"
+VLLM_API_URL = "http://localhost:8004/v1"
+VLLM_API_KEY = "EMPTY" 
+
+# Initialize Client
+client = OpenAI(
+    base_url=VLLM_API_URL,
+    api_key=VLLM_API_KEY,
+)
+
+# ===========================
+# INFERENCE FUNCTION
+# ===========================
+def infer_reasonableness(
+    reference_summary: str,
+    generated_summary: str,
+    readability_level: str,
+    subclaim_text: str,
+    result: int,
+):
+    """
+    Predict reasonableness using the local vLLM server.
+    No error handling: validation or connection errors will raise exceptions.
+    """
+
+    # ---- Build inference prompt ----
+    prompt = f"""
+You are an impartial medical summarization evaluator.
+
+Goal:
+Decide whether the inclusion or omission of ONE specific subclaim from the reference summary is *reasonable*, given the readability level of the generated summary.
+
+Readability Criteria:
+- Easy: for non-medical readers; emphasize main story and outcomes; omit numerical data, anatomy, and test details.
+- Intermediate: for general educated readers; keep main findings but simplify phrasing.
+- Hard: for clinical or technical readers; maintain diagnostic accuracy and essential quantitative or anatomic content.
+
+Judging rules:
+* Base your decision strictly on what appears in the generated summary.
+* If result = 0 (subclaim omitted) and the omitted detail is clearly technical or numerical for the given level, choose "reasonable".
+* If result = 0 and the subclaim is essential to the main story, choose "unreasonable".
+* Stay consistent between `result`, justification, and readability level.
+
+### Inputs
+Readability Level: {readability_level}
+Reference Summary: {reference_summary}
+Generated Summary: {generated_summary}
+Subclaim: "{subclaim_text}"
+Result: {result}   # 1 = supported (included), 0 = omitted
+
+### Task
+Respond **only** with the following JSON object:
+
+{{
+  "reasonableness": "<reasonable | partially_reasonable | unreasonable>",
+  "justification": "<short clear explanation>"
+}}
+""".strip()
+
+    messages = [{"role": "user", "content": prompt}]
+
+    # ---- Call vLLM Server ----
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=messages,
+        temperature=0.2,
+        max_tokens=200,
+        top_p=0.8,
+    )
+
+    output_text = response.choices[0].message.content
+
+    # ---- Clean Output (Handle Thinking & Markdown) ----
+    try:
+        if "</think>" in output_text:
+            output_text = output_text.split("</think>")[1]
+        
+        clean_text = output_text.strip().replace("```json", "").replace("```", "").strip()
+        # import ipdb; ipdb.set_trace()
+        t=ast.literal_eval(clean_text)
+
+        # ---- Parse JSON (Will raise JSONDecodeError if invalid) ----
+        return t
+    except Exception as e:
+        return output_text
+
+
+# ===========================
+# MAIN EXECUTION
+# ===========================
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_path", type=str, required=True,
+                        help="Path to the JSON file containing evaluation data.")
+    args = parser.parse_args()
+    data_path = args.data_path
+    # data_path = '/home/mshahidul/readctrl/data/concise_complete_attr_cal_v3/evaluated_metrics_0_100.json'
+    file_name=os.path.basename(data_path)
+    
+    # Open file directly (Will raise FileNotFoundError if missing)
+    with open(data_path, 'r') as f:
+        dataset = json.load(f)
+        
+    # print(f"Loaded {len(dataset)} examples. Starting inference...")
+    save_path = f'/home/mshahidul/readctrl/data/completeness_resoning_result/{file_name}'
+    full_results = []
+    if os.path.exists(save_path):
+        with open(save_path, 'r') as f:
+            full_results = json.load(f)
+
+    import tqdm
+    for item in tqdm.tqdm(dataset):
+        if any(d['id'] == item['id'] for d in full_results):
+            continue  
+        reference_summary = item['summary']
+        temp2={}
+        for label in ['easy', 'intermediate', 'hard']:
+            generated_summary = item[f'{label}_text']
+            subclaim_list = item['metrics'][f'{label}']['completeness']['details']
+            temp=[]
+            for idx, subclaim in enumerate(subclaim_list):
+                
+                # Check status (assumes subclaim variable holds the status string)
+                result = 1 if subclaim['label'] == 'supported' else 0
+                
+                if result ==0:
+                    output = infer_reasonableness(
+                                reference_summary=reference_summary,
+                                generated_summary=generated_summary,
+                                readability_level=label,
+                                subclaim_text=subclaim['subclaim'],
+                                result=result,
+                        )
+                        
+                    temp.append({
+                                'subclaim': subclaim['subclaim'],
+                                'output': output
+                            })
+                else:
+                    temp.append({
+                                'subclaim': subclaim['subclaim'],
+                                'output': {
+                                    'reasonableness': 'reasonable',
+                                    'justification': 'The subclaim is included in the generated summary, hence it is reasonable.'
+                                }
+                            })
+
+            temp2[label] = {
+                'results': temp
+            }
+        full_results.append({
+            'id': item['id'],
+            'completeness': temp2
+        })
+        if len(full_results) % 10 == 0:
+            with open(save_path, 'w') as f:
+                json.dump(full_results, f, indent=2, ensure_ascii=False)
+
+    with open(save_path, 'w') as f:
+        json.dump(full_results, f, indent=2, ensure_ascii=False)
+
+                
+                

code/finetune-inference/old/extracting_subclaims.py

@@ -0,0 +1,196 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_NAME = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims_BF16_merged"
+API_URL = "http://localhost:8015/v1"
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    return f"""
+You are an expert medical annotator. Extract granular, factual subclaims.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Rules:
+- Use only information explicitly present in the text.
+- Do not infer or hallucinate.
+- Subclaims must be atomic and factual.
+- Return ONLY a JSON list of strings.
+
+Medical Text:
+{medical_text}
+
+Return output as:
+[
+  "subclaim 1",
+  "subclaim 2",
+  ...
+]
+"""
+
+# -----------------------------
+#  INFERENCE FUNCTION
+# -----------------------------
+def infer_subclaims(medical_text: str, temperature: float = 0.2) -> list:
+    if not medical_text or medical_text.strip() == "":
+        return []
+
+    final_prompt = extraction_prompt(medical_text)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": final_prompt}],
+            max_tokens=1000,
+            temperature=temperature,
+            top_p=0.9,
+        )
+        res = response.choices[0].message.content.strip()
+        res = res.split("</think>")[-1].strip()
+
+        # try parse JSON
+        try:
+            return json.loads(res)
+        except:
+            return res
+
+    except Exception as e:
+        print(f"API error: {e}")
+        return []
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--file1", type=str, required=True,
+                        help="Path to synthetic_data_es_raw_592.json")
+    parser.add_argument("--file2", type=str, required=True,
+                        help="Path to multiclinsum_gs_train_es.json")
+
+    parser.add_argument("--start_index", type=int, default=0,
+                        help="Start index for processing")
+    parser.add_argument("--end_index", type=int, default=-1,
+                        help="End index for processing (exclusive). -1 = until end")
+
+    args = parser.parse_args()
+
+    FILE1 = args.file1
+    FILE2 = args.file2
+
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    # Output filename includes the range
+    OUTPUT_FILE = os.path.join(
+        SAVE_FOLDER,
+        f"extracted_subclaims_{args.start_index}_{args.end_index}.json"
+    )
+
+    # -----------------------------
+    # Load files
+    # -----------------------------
+    print("Loading input files...")
+    with open(FILE1, "r") as f:
+        file1_data = {x["id"]: x for x in json.load(f)}
+
+    with open(FILE2, "r") as f:
+        file2_data = {x["id"]: x for x in json.load(f)}
+
+    # -----------------------------
+    # Merge and slice by range
+    # -----------------------------
+    all_ids = sorted(list(set(file1_data.keys()) | set(file2_data.keys())))
+
+    total_items = len(all_ids)
+
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_items
+
+    slice_ids = all_ids[start:end]
+
+    print(f"Total IDs: {total_items}")
+    print(f"Processing range: {start} → {end} (count={len(slice_ids)})")
+
+    # -----------------------------
+    # Resume mode
+    # -----------------------------
+    result = []
+    if os.path.exists(OUTPUT_FILE):
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                result = json.load(f)
+        except:
+            result = []
+
+    existing_ids = {r["id"] for r in result}
+
+    # -----------------------------
+    # Process items
+    # -----------------------------
+    for _id in tqdm.tqdm(slice_ids):
+
+        if _id in existing_ids:
+            continue
+
+        # FILE1 text
+        easy_text = inter_text = hard_text = ""
+        if _id in file1_data:
+            rv = file1_data[_id]["readability_versions"]
+            easy_text = rv.get("easy", {}).get("text", "")
+            inter_text = rv.get("intermediate", {}).get("text", "")
+            hard_text = rv.get("hard", {}).get("text", "")
+
+        # FILE2 text
+        fulltext = summary = ""
+        if _id in file2_data:
+            fulltext = file2_data[_id].get("fulltext", "")
+            summary = file2_data[_id].get("summary", "")
+
+        # inference
+        easy_sub = infer_subclaims(easy_text)
+        inter_sub = infer_subclaims(inter_text)
+        hard_sub = infer_subclaims(hard_text)
+        fulltext_sub = infer_subclaims(fulltext)
+        summary_sub = infer_subclaims(summary)
+
+        # append
+        result.append({
+            "id": _id,
+
+            "easy_text": easy_text,
+            "easy_subclaims": easy_sub,
+
+            "intermediate_text": inter_text,
+            "intermediate_subclaims": inter_sub,
+
+            "hard_text": hard_text,
+            "hard_subclaims": hard_sub,
+
+            "fulltext": fulltext,
+            "fulltext_subclaims": fulltext_sub,
+
+            "summary": summary,
+            "summary_subclaims": summary_sub
+        })
+
+        # save frequently
+        if len(result) % 20 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(result, f, indent=4, ensure_ascii=False)
+
+    # final save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(result, f, indent=4, ensure_ascii=False)
+
+    print(f"Done! Saved to: {OUTPUT_FILE}")

code/finetune-inference/old/extracting_subclaims_v2.py

@@ -0,0 +1,170 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_NAME = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-extraction-8b_ctx"
+API_URL = "http://localhost:8004/v1"
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    return f"""
+You are an expert medical annotator. Extract granular, factual subclaims.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Instructions:
+1. Read the provided medical text.
+2. Break it into clear, objective, atomic subclaims.
+3. Each subclaim must come directly from the text.
+4. Do not add, guess, or infer information.
+5. Each subclaim should be short, specific, and verifiable.
+6. Return ONLY a Python-style list of strings.
+
+Medical Text:
+{medical_text}
+
+Return output as:
+[
+  "subclaim 1",
+  "subclaim 2",
+  ...
+]
+"""
+
+# -----------------------------
+#  INFERENCE FUNCTION
+# -----------------------------
+def infer_subclaims(medical_text: str, temperature: float = 0.2) -> list:
+    if not medical_text or medical_text.strip() == "":
+        return []
+
+    final_prompt = extraction_prompt(medical_text)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": final_prompt}],
+            max_tokens=1000,
+            temperature=temperature,
+            top_p=0.9,
+        )
+        res = response.choices[0].message.content.strip()
+        
+        # Handle cases where the model might include <think> tags or markdown code blocks
+        if "</think>" in res:
+            res = res.split("</think>")[-1].strip()
+        
+        if res.startswith("```json"):
+            res = res.replace("```json", "").replace("```", "").strip()
+
+        try:
+            return json.loads(res)
+        except:
+            # Fallback if JSON parsing fails but some text is returned
+            return [res]
+
+    except Exception as e:
+        print(f"API error for text snippet: {e}")
+        return []
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/classified_readability/classified_multiclinsum_test_en.json",
+                        help="Path to input JSON file")
+    parser.add_argument("--start_index", type=int, default=0,
+                        help="Start index for processing")
+    parser.add_argument("--end_index", type=int, default=-1,
+                        help="End index for processing (exclusive). -1 = until end")
+
+    args = parser.parse_args()
+
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    # Output filename based on the source and range
+    base_name = os.path.basename(args.input_file).replace(".json", "")
+    OUTPUT_FILE = os.path.join(
+        SAVE_FOLDER,
+        f"subclaims_{base_name}_{args.start_index}_{args.end_index}.json"
+    )
+
+    # -----------------------------
+    # Load data
+    # -----------------------------
+    print(f"Loading {args.input_file}...")
+    with open(args.input_file, "r") as f:
+        data = json.load(f)
+
+    total_items = len(data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_items
+    
+    # Slice the data based on arguments
+    work_items = data[start:end]
+
+    print(f"Total records in file: {total_items}")
+    print(f"Processing range: {start} → {end} (count={len(work_items)})")
+
+    # -----------------------------
+    # Resume mode
+    # -----------------------------
+    result = []
+    if os.path.exists(OUTPUT_FILE):
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                result = json.load(f)
+            print(f"Resuming from existing file. {len(result)} items already processed.")
+        except:
+            result = []
+
+    existing_ids = {r["id"] for r in result}
+
+    # -----------------------------
+    # Process items
+    # -----------------------------
+    for item in tqdm.tqdm(work_items):
+        _id = item.get("id")
+        
+        if _id in existing_ids:
+            continue
+
+        fulltext = item.get("fulltext", "")
+        summary = item.get("summary", "")
+
+        # Run inference for both fields
+        fulltext_sub = infer_subclaims(fulltext)
+        summary_sub = infer_subclaims(summary)
+
+        # Build output object
+        result.append({
+            "id": _id,
+            "fulltext": fulltext,
+            "fulltext_subclaims": fulltext_sub,
+            "summary": summary,
+            "summary_subclaims": summary_sub,
+            "readability_score": item.get("readability_score", None)
+        })
+
+        # Periodic save to prevent data loss
+        if len(result) % 10 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(result, f, indent=4, ensure_ascii=False)
+
+    # Final save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(result, f, indent=4, ensure_ascii=False)
+
+    print(f"Success! Results saved to: {OUTPUT_FILE}")

code/finetune-inference/old/extracting_subclaims_v3.py

@@ -0,0 +1,175 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_NAME = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-extraction-8b_ctx"
+API_URL = "http://localhost:8004/v1"
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    return f"""
+You are an expert medical annotator. Extract granular, factual subclaims.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Instructions:
+1. Read the provided medical text.
+2. Break it into clear, objective, atomic subclaims.
+3. Each subclaim must come directly from the text.
+4. Do not add, guess, or infer information.
+5. Each subclaim should be short, specific, and verifiable.
+6. Return ONLY a Python-style list of strings.
+
+Medical Text:
+{medical_text}
+
+Return output as:
+[
+  "subclaim 1",
+  "subclaim 2",
+  ...
+]
+"""
+
+# -----------------------------
+#  INFERENCE FUNCTION
+# -----------------------------
+def infer_subclaims(medical_text: str, temperature: float = 0.2) -> list:
+    if not medical_text or medical_text.strip() == "":
+        return []
+
+    final_prompt = extraction_prompt(medical_text)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": final_prompt}],
+            max_tokens=1000,
+            temperature=temperature,
+            top_p=0.9,
+        )
+        res = response.choices[0].message.content.strip()
+        
+        # Handle cases where the model might include <think> tags or markdown code blocks
+        if "</think>" in res:
+            res = res.split("</think>")[-1].strip()
+        
+        if res.startswith("```json"):
+            res = res.replace("```json", "").replace("```", "").strip()
+
+        try:
+            return json.loads(res)
+        except:
+            # Fallback if JSON parsing fails but some text is returned
+            return [res]
+
+    except Exception as e:
+        print(f"API error for text snippet: {e}")
+        return []
+
+
+# ... (Configuration and extraction_prompt remain the same) ...
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/synthetic_dataset_diff_labels/syn_data_with_gs_summary_en.json",
+                        help="Path to input JSON file")
+    parser.add_argument("--start_index", type=int, default=0,
+                        help="Start index for processing")
+    parser.add_argument("--end_index", type=int, default=-1,
+                        help="End index for processing (exclusive). -1 = until end")
+
+    args = parser.parse_args()
+
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    base_name = os.path.basename(args.input_file).replace(".json", "")
+    OUTPUT_FILE = os.path.join(
+        SAVE_FOLDER,
+        f"subclaims_with_generated_{base_name}_{args.start_index}_{args.end_index}.json"
+    )
+
+    print(f"Loading {args.input_file}...")
+    with open(args.input_file, "r") as f:
+        data = json.load(f)
+
+    total_items = len(data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_items
+    work_items = data[start:end]
+
+    result = []
+    if os.path.exists(OUTPUT_FILE):
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                result = json.load(f)
+            print(f"Resuming. {len(result)} items already processed.")
+        except:
+            result = []
+
+    # Using "index" or "id" as the unique identifier based on your JSON snippet
+    existing_ids = {r.get("index") or r.get("id") for r in result}
+
+    for item in tqdm.tqdm(work_items):
+        # Handle different ID key names
+        curr_id = item.get("index") if item.get("index") is not None else item.get("id")
+        
+        if curr_id in existing_ids:
+            continue
+
+        # 1. Process standard fields
+        fulltext = item.get("fulltext", "")
+        summary = item.get("summary", "")
+        
+        fulltext_sub = infer_subclaims(fulltext)
+        summary_sub = infer_subclaims(summary)
+
+        # 2. Process all generated texts (diff_label_texts)
+        # We will create a mirror dictionary to store the subclaims
+        diff_label_subclaims = {}
+        generated_texts = item.get("diff_label_texts", {})
+
+        for label, text in generated_texts.items():
+            if text:
+                diff_label_subclaims[label] = infer_subclaims(text)
+            else:
+                diff_label_subclaims[label] = []
+
+        # 3. Build output object
+        output_item = {
+            "index": curr_id,
+            "fulltext": fulltext,
+            "fulltext_subclaims": fulltext_sub,
+            "summary": summary,
+            "summary_subclaims": summary_sub,
+            "diff_label_texts": generated_texts,
+            "diff_label_subclaims": diff_label_subclaims, # New field
+            "readability_score": item.get("readability_score", None)
+        }
+        
+        result.append(output_item)
+
+        # Periodic save
+        if len(result) % 10 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(result, f, indent=4, ensure_ascii=False)
+
+    # Final save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(result, f, indent=4, ensure_ascii=False)
+
+    print(f"Success! Results saved to: {OUTPUT_FILE}")

code/finetune-inference/old/inference.py

@@ -0,0 +1,91 @@
+import argparse
+import os
+import json
+import sys
+sys.path.append(os.path.abspath('/home/mshahidul/'))
+from gpu_selection import _gpu_selection_
+# 1. Argparse for path
+parser = argparse.ArgumentParser(description="Translation Evaluation")
+parser.add_argument("--path", type=str, default="/home/mshahidul/readctrl/generating_data/tik_ache/es_syntheticV3.json", help="Path to the JSON file")
+parser.add_argument("--cuda", type=str, default="3", help="CUDA device id, e.g., '0' or '0,1' for multiple GPUs")
+args = parser.parse_args()
+
+if args.cuda is not None:
+    os.environ["CUDA_VISIBLE_DEVICES"] = args.cuda
+    print(f"🎮🎮 Using CUDA device: {args.cuda}")
+else:
+    _gpu_selection_()
+
+# 2. Output directory and file
+out_dir = "/home/mshahidul/readctrl/results/"
+os.makedirs(os.path.dirname(out_dir), exist_ok=True)
+file_name = os.path.basename(args.path)
+out_path = os.path.join(out_dir, file_name)
+
+# 3. Load already evaluated results if exist
+results = []
+completed_keys = set()
+if os.path.exists(out_path):
+    with open(out_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+    for r in results:
+        completed_keys.add((r["article"], r["gold_summary"]))
+
+# 4. Load dataset
+with open(args.path, "r", encoding="utf-8") as f:
+    dataset = json.load(f)
+from unsloth import FastLanguageModel
+import torch
+# 5. Load model
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name = "/home/mshahidul/readctrl/finetuned_models/es_synthetic_data_creation_Qwen3_14B_v1",
+    max_seq_length = 4092,
+    load_in_4bit = True,
+    load_in_8bit = False,
+    full_finetuning = False,
+)
+from prompt_generate import generate_prompt
+# 6. Evaluation loop
+import tqdm
+for item in tqdm.tqdm(dataset):
+    key = (item["article"], item["gold_summary"])
+    if key in completed_keys:
+        continue
+
+    for band in ["B1", "B2", "B3"]:
+        prompt = generate_prompt(item['article'],item['gold_summary'],band,"es")
+
+        messages = [{"role": "user", "content": prompt+"\n"}]
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+        inputs = tokenizer(text, return_tensors="pt").to("cuda")
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=1000,
+            temperature=0.1,
+            top_p=0.8,
+            top_k=5,
+        )
+        output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        #answer = output_text.split("</think>")[1].strip()
+
+        results.append({
+            "article": item["article"],
+            "gold_summary": item["gold_summary"],
+            "band": band,
+            "lang": "es",
+            "synthetic_summary": output_text,
+        })
+        completed_keys.add(key)
+        # Save every 30 results
+        if len(results) % 30 == 0:
+            with open(out_path, "w", encoding="utf-8") as f:
+                json.dump(results, f, ensure_ascii=False, indent=2)
+
+# 7. Final save
+with open(out_path, "w", encoding="utf-8") as f:
+    json.dump(results, f, ensure_ascii=False, indent=2)

code/finetune-inference/old/inferenceV2_without_context.py

@@ -0,0 +1,137 @@
+import argparse
+import os
+import json
+import sys
+sys.path.append(os.path.abspath('/home/mshahidul/'))
+from gpu_selection import _gpu_selection_
+# 1. Argparse for path
+parser = argparse.ArgumentParser(description="Translation Evaluation")
+# parser.add_argument("--out_path", type=str, default="/home/mshahidul/readctrl/generating_data/tik_ache/es_syntheticV3.json", help="Path to the JSON file")
+parser.add_argument("--cuda", type=str, default="3", help="CUDA device id, e.g., '0' or '0,1' for multiple GPUs")
+parser.add_argument("--model_name", type=str, default="/home/mshahidul/readctrl/finetuned_models/es_synthetic_data_creation_Qwen3_14B_v2", help="Path to the finetuned model")
+parser.add_argument("--temperature", type=float, default=0.1, help="Generation temperature")
+args = parser.parse_args()
+# out_path = args.out_path
+model_name = args.model_name
+temperature = args.temperature
+if args.cuda is not None:
+    os.environ["CUDA_VISIBLE_DEVICES"] = args.cuda
+    print(f"🎮🎮 Using CUDA device: {args.cuda}")
+else:
+    _gpu_selection_()
+
+prompts={
+"easy":'''
+You are an assistant that rewrites Spanish texts to make them very simple and easy to understand.
+Your goal is to rewrite the provided input text for younger readers (Fernández Huerta 70–100; grade 5–7).
+Use short sentences, simple words, and friendly tone. Avoid technical or complex expressions.
+Keep all important factual details, but remove jargon.
+Return only the rewritten text without commentary.
+''',
+
+'intermediate':'''
+You are an assistant specialized in rewriting Spanish texts with medium readability.
+Your task is to rewrite the provided input text for general or high‑school‑level readers (Fernández Huerta 50–70; grade 8–12).
+Use clear and complete sentences, moderately complex vocabulary, and structured narration.
+Retain all relevant medical or factual information, but phrase it in accessible language.
+Return only the rewritten text with no explanations.
+''',
+
+'hard':'''
+You are an assistant that rewrites Spanish medical texts with professional, technical precision.
+Rewrite the following input text using specialized, academic terminology and information‑dense phrasing.
+The output must target a Fernández Huerta readability index between 0 and 50 (university/professional level).
+Use clinical vocabulary, formal register, and detailed description of pathophysiology, procedures, and findings.
+Return only the rewritten text.
+'''
+}
+
+# 2. Output directory and file
+path="/home/mshahidul/readctrl/data/testing_data/multiclinsum_test_es.json"
+out_dir = "/home/mshahidul/readctrl/results/v2_without_context"
+os.makedirs(out_dir, exist_ok=True)
+# file_name = os.path.basename(path)
+# out_path = os.path.join(out_dir, file_name.replace(".json", "_V2.json"))
+# os.makedirs(os.path.dirname(out_dir), exist_ok=True)
+if os.path.exists(model_name):
+    out_path = out_dir + f"/temp{temperature}_qwen3-14B_finetuned.json"
+else:
+    out_path = out_dir + f"/temp{temperature}_qwen3-14B_base.json"
+# 3. Load already evaluated results if exist
+results = []
+completed_keys = set()
+if os.path.exists(out_path):
+    with open(out_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+    for r in results:
+        completed_keys.add(r["fulltext"])
+
+# 4. Load dataset
+with open(path, "r", encoding="utf-8") as f:
+    dataset = json.load(f)
+dataset=dataset[0:50]  
+from unsloth import FastLanguageModel
+import torch
+# 5. Load model
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name = model_name,
+    max_seq_length = 4092,
+    load_in_4bit = False,
+    load_in_8bit = False,
+    full_finetuning = False,
+)
+
+import tqdm
+for item in tqdm.tqdm(dataset):
+    key = item["fulltext"]
+    if key in completed_keys:
+        continue
+
+    for band in ["easy", "intermediate", "hard"]:
+        prompt = prompts[band]+'\n\n'+"Input text:\n"+item['fulltext']
+
+        # messages = [{"role": "user", "content": prompt+"\n"}]
+        messages = [
+                {"role": "system", "content": prompts[band].strip()},
+                {"role": "user", "content": "Input text:\n" + item["fulltext"].strip()}
+                ]
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+        # input_ids = tokenizer(item["fulltext"], return_tensors="pt").input_ids
+        # input_len = input_ids.shape[1]
+        inputs = tokenizer(text, return_tensors="pt").to("cuda")
+        input_len = inputs.input_ids.shape[1]
+        # Define proportional multipliers for each readability level
+        length_factors = {"easy": 0.5, "intermediate": 0.8, "hard": 1.1}
+
+        # Compute adaptive max_new_tokens
+        max_new_tokens = int(min(1200, max(150, input_len * length_factors[band])))
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=0.9,
+            top_k=45,
+        )
+        output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        #answer = output_text.split("</think>")[1].strip()
+
+        results.append({
+            "fulltext": item["fulltext"],
+            "band": band,
+            "lang": "es",
+            "synthetic_summary": output_text,
+        })
+        completed_keys.add(key)
+        # Save every 10 results
+        if len(results) % 3 == 0:
+            with open(out_path, "w", encoding="utf-8") as f:
+                json.dump(results, f, ensure_ascii=False, indent=2)
+
+# 7. Final save
+with open(out_path, "w", encoding="utf-8") as f:
+    json.dump(results, f, ensure_ascii=False, indent=2)

code/finetune-inference/old/inferenceV3.py

@@ -0,0 +1,161 @@
+import argparse
+import os
+import json
+import sys
+sys.path.append(os.path.abspath('/home/mshahidul/'))
+from gpu_selection import _gpu_selection_
+
+parser = argparse.ArgumentParser(description="Readability Controlled Generation")
+parser.add_argument("--cuda", type=str, default="3")
+parser.add_argument("--model_name", type=str, default="/home/mshahidul/readctrl/finetuned_models/es_synthetic_data_creation_Qwen3_14B_v2")
+parser.add_argument("--temperature", type=float, default=0.1)
+args = parser.parse_args()
+
+model_name = args.model_name
+temperature = args.temperature
+
+if args.cuda is not None:
+    os.environ["CUDA_VISIBLE_DEVICES"] = args.cuda
+    print(f"🎮🎮 Using CUDA device: {args.cuda}")
+else:
+    _gpu_selection_()
+
+prompts = {
+"easy": '''
+You are an assistant that rewrites Spanish texts to make them very simple and easy to understand.
+Your goal is to rewrite the provided input text for younger readers (Fernández Huerta 70–100; grade 5–7).
+Use short sentences, simple words, and friendly tone. Avoid technical or complex expressions.
+Keep all important factual details, but remove jargon.
+Return only the rewritten text without commentary.
+''',
+"intermediate": '''
+You are an assistant specialized in rewriting Spanish texts with medium readability.
+Your task is to rewrite the provided input text for general or high‑school‑level readers (Fernández Huerta 50–70; grade 8–12).
+Use clear and complete sentences, moderately complex vocabulary, and structured narration.
+Retain all relevant medical or factual information, but phrase it in accessible language.
+Return only the rewritten text with no explanations.
+''',
+"hard": '''
+You are an assistant that rewrites Spanish medical texts with professional, technical precision.
+Rewrite the following input text using specialized, academic terminology and information‑dense phrasing.
+The output must target a Fernández Huerta readability index between 0 and 50 (university/professional level).
+Use clinical vocabulary, formal register, and detailed description of pathophysiology, procedures, and findings.
+Return only the rewritten text.
+'''
+}
+
+# -------- New Part: Load keyword–definition dataset ----------
+kw_file = "/home/mshahidul/readctrl/data/kyw_def_train/kyw_gen_gpt5.json"
+with open(kw_file, "r", encoding="utf-8") as f:
+    definitions_data = json.load(f)
+
+# Build quick lookup: id -> glossary text
+def_map = {}
+for obj in definitions_data:
+    cid = obj.get("id")
+    kwlist = obj.get("medical_keywords", [])
+    defs_str = ""
+    if kwlist:
+        defs_lines = [f"• {d['term']} — {d['definition']}" for d in kwlist]
+        defs_str = "Relevant medical definitions:\n" + "\n".join(defs_lines)
+    def_map[cid] = defs_str
+# --------------------------------------------------------------
+
+path = "/home/mshahidul/readctrl/data/testing_data/multiclinsum_test_es.json"
+out_dir = "/home/mshahidul/readctrl/results/v3_context"
+os.makedirs(out_dir, exist_ok=True)
+
+if os.path.exists(model_name):
+    out_path = out_dir + f"/temp{temperature}_qwen3-14B_finetuned_with_defs.json"
+else:
+    out_path = out_dir + f"/temp{temperature}_qwen3-14B_base_with_defs.json"
+
+results, completed_keys = [], set()
+if os.path.exists(out_path):
+    with open(out_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+    for r in results:
+        completed_keys.add(r["fulltext"])
+
+# -------- Load main dataset -----------
+with open(path, "r", encoding="utf-8") as f:
+    dataset = json.load(f)
+dataset = dataset[0:50]
+
+from unsloth import FastLanguageModel
+import torch
+
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name=model_name,
+    max_seq_length=4092,
+    load_in_4bit=False,
+    load_in_8bit=False,
+    full_finetuning=False,
+)
+
+import tqdm
+for item in tqdm.tqdm(dataset):
+    key = item["fulltext"]
+    if key in completed_keys:
+        continue
+    item_id = item["id"]
+    glossary = def_map.get(item_id, "")  # retrieve glossary if exists
+
+    for band in ["easy", "intermediate", "hard"]:
+        # Append definitions below the case text
+        user_content = f"Input text:\n{item['fulltext'].strip()}"
+        if glossary:
+            user_content += "\n\n" + glossary
+
+        messages = [
+            {"role": "system", "content": prompts[band].strip()},
+            {"role": "user", "content": user_content}
+        ]
+
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+
+        inputs = tokenizer(text, return_tensors="pt").to("cuda")
+        input_len = inputs.input_ids.shape[1]
+        length_factors = {"easy": 0.5, "intermediate": 0.8, "hard": 1.1}
+        max_new_tokens = int(min(1200, max(150, input_len * length_factors[band])))
+
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=0.9,
+            top_k=45,
+        )
+        output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+
+        results.append({
+            "id": item_id,
+            "fulltext": item["fulltext"],
+            "band": band,
+            "lang": "es",
+            "synthetic_summary": output_text,
+            "definitions_used": bool(glossary)  # track whether glossary applied
+        })
+
+        completed_keys.add(key)
+        if len(results) % 3 == 0:
+            with open(out_path, "w", encoding="utf-8") as f:
+                json.dump(results, f, ensure_ascii=False, indent=2)
+
+with open(out_path, "w", encoding="utf-8") as f:
+    json.dump(results, f, ensure_ascii=False, indent=2)
+
+
+from notifier import send_notification
+send_notification(
+    "process-complete1507034",
+    f"Finished inference with model {model_name} at temperature {temperature}. Results saved to {out_path}",
+    title="Inference Complete",
+    priority="default",
+    tags="tada"
+)

code/finetune-inference/old/inferenceV3_temp.py

@@ -0,0 +1,144 @@
+import argparse
+import os
+import json
+import sys
+
+
+parser = argparse.ArgumentParser(description="Readability Controlled Generation")
+parser.add_argument("--model_name", type=str, default="/home/mshahidul/readctrl/finetuned_models/es_synthetic_data_creation_Qwen3_14B_v2")
+parser.add_argument("--temperature", type=float, default=0.1)
+args = parser.parse_args()
+
+model_name = args.model_name
+temperature = args.temperature
+
+
+prompts = {
+"easy": '''
+You are an assistant that rewrites Spanish texts to make them very simple and easy to understand.
+Your goal is to rewrite the provided input text for younger readers (Fernández Huerta 70–100; grade 5–7).
+Use short sentences, simple words, and friendly tone. Avoid technical or complex expressions.
+Keep all important factual details, but remove jargon.
+Return only the rewritten text without commentary.
+''',
+"intermediate": '''
+You are an assistant specialized in rewriting Spanish texts with medium readability.
+Your task is to rewrite the provided input text for general or high‑school‑level readers (Fernández Huerta 50–70; grade 8–12).
+Use clear and complete sentences, moderately complex vocabulary, and structured narration.
+Retain all relevant medical or factual information, but phrase it in accessible language.
+Return only the rewritten text with no explanations.
+''',
+"hard": '''
+You are an assistant that rewrites Spanish medical texts with professional, technical precision.
+Rewrite the following input text using specialized, academic terminology and information‑dense phrasing.
+The output must target a Fernández Huerta readability index between 0 and 50 (university/professional level).
+Use clinical vocabulary, formal register, and detailed description of pathophysiology, procedures, and findings.
+Return only the rewritten text.
+'''
+}
+
+# -------- New Part: Load keyword–definition dataset ----------
+kw_file = "/home/mshahidul/readctrl/data/kyw_def_train/kyw_gen_gpt5.json"
+with open(kw_file, "r", encoding="utf-8") as f:
+    definitions_data = json.load(f)
+
+# Build quick lookup: id -> glossary text
+def_map = {}
+for obj in definitions_data:
+    cid = obj.get("id")
+    kwlist = obj.get("medical_keywords", [])
+    defs_str = ""
+    if kwlist:
+        defs_lines = [f"• {d['term']} — {d['definition']}" for d in kwlist]
+        defs_str = "Relevant medical definitions:\n" + "\n".join(defs_lines)
+    def_map[cid] = defs_str
+# --------------------------------------------------------------
+
+path = "/home/mshahidul/readctrl/data/testing_data/multiclinsum_test_es.json"
+out_dir = "/home/mshahidul/readctrl/results/v3"
+os.makedirs(out_dir, exist_ok=True)
+
+if os.path.exists(model_name):
+    out_path = out_dir + f"/temp{temperature}_qwen3-14B_finetuned_with_defs.json"
+else:
+    out_path = out_dir + f"/temp{temperature}_qwen3-14B_base_with_defs.json"
+
+results, completed_keys = [], set()
+if os.path.exists(out_path):
+    with open(out_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+    for r in results:
+        completed_keys.add(r["fulltext"])
+
+# -------- Load main dataset -----------
+with open(path, "r", encoding="utf-8") as f:
+    dataset = json.load(f)
+dataset = dataset[0:50]
+
+from unsloth import FastLanguageModel
+import torch
+
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name=model_name,
+    max_seq_length=4092,
+    load_in_4bit=False,
+    load_in_8bit=False,
+    full_finetuning=False,
+)
+
+import tqdm
+for item in tqdm.tqdm(dataset):
+    key = item["fulltext"]
+    if key in completed_keys:
+        continue
+    item_id = item["id"]
+    glossary = def_map.get(item_id, "")  # retrieve glossary if exists
+
+    for band in ["easy", "intermediate", "hard"]:
+        # Append definitions below the case text
+        user_content = f"Input text:\n{item['fulltext'].strip()}"
+        if glossary:
+            user_content += "\n\n" + glossary
+
+        messages = [
+            {"role": "system", "content": prompts[band].strip()},
+            {"role": "user", "content": user_content}
+        ]
+
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+
+        inputs = tokenizer(text, return_tensors="pt").to("cuda")
+        input_len = inputs.input_ids.shape[1]
+        length_factors = {"easy": 0.5, "intermediate": 0.8, "hard": 1.1}
+        max_new_tokens = int(min(1200, max(150, input_len * length_factors[band])))
+
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=0.9,
+            top_k=45,
+        )
+        output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+
+        results.append({
+            "id": item_id,
+            "fulltext": item["fulltext"],
+            "band": band,
+            "lang": "es",
+            "synthetic_summary": output_text,
+            "definitions_used": bool(glossary)  # track whether glossary applied
+        })
+
+        completed_keys.add(key)
+        if len(results) % 3 == 0:
+            with open(out_path, "w", encoding="utf-8") as f:
+                json.dump(results, f, ensure_ascii=False, indent=2)
+
+with open(out_path, "w", encoding="utf-8") as f:
+    json.dump(results, f, ensure_ascii=False, indent=2)

code/finetune-inference/old/inferenceV4.py

@@ -0,0 +1,154 @@
+import argparse
+import os
+import json
+import sys
+sys.path.append(os.path.abspath('/home/mshahidul/'))
+from gpu_selection import _gpu_selection_
+
+parser = argparse.ArgumentParser(description="Readability Controlled Generation")
+parser.add_argument("--cuda", type=str, default="3")
+parser.add_argument("--model_name", type=str, default="/home/mshahidul/readctrl/finetuned_models/es_synthetic_data_creation_Qwen3_14B_v2")
+parser.add_argument("--temperature", type=float, default=0.1)
+args = parser.parse_args()
+
+model_name = args.model_name
+temperature = args.temperature
+
+if args.cuda is not None:
+    os.environ["CUDA_VISIBLE_DEVICES"] = args.cuda
+    print(f"🎮🎮 Using CUDA device: {args.cuda}")
+else:
+    _gpu_selection_()
+
+prompts={
+"easy":'''
+Reescribe el siguiente informe médico en español con un nivel de lectura fácil correspondiente a un puntaje FH entre 70 y 100 (texto muy comprensible).
+Usa oraciones cortas y directas, vocabulario cotidiano, estructuras simples y explicaciones claras de términos médicos. El tono debe ser empático y accesible, como si estuvieras explicando la situación a un paciente o familiar sin conocimientos médicos.
+Mantén los datos clínicos y resultados esenciales, pero reemplaza o aclara tecnicismos con frases simples. Evita abreviaturas o siglas sin explicación.
+''',
+"intermediate": '''
+Reformula el siguiente informe médico en español con un nivel de lectura intermedio, correspondiente a un puntaje FH entre 50 y 70 (texto de dificultad moderada).
+Usa lenguaje formal pero comprensible, adecuado para lectores con educación general o estudiantes del área de salud. Mantén la precisión médica, pero agrega explicaciones breves tras los términos técnicos. Alterna oraciones simples y compuestas, con buena fluidez y cohesión.
+El texto debe sonar profesional, informativo y claro, sin llegar a la densidad típica de lenguaje técnico especializado.
+''',
+"hard": '''
+Reescribe el siguiente informe médico en español con un nivel de lectura avanzado o técnico, correspondiente a un puntaje FH entre 0 y 50 (texto especializado).
+Usa terminología médica precisa, estructuras sintácticas complejas y tono formal típico de documentos clínicos o publicaciones científicas. No simplifiques ni expliques los tecnicismos; conserva la exactitud conceptual y la nomenclatura profesional.
+Refleja el razonamiento clínico, hallazgos y juicios médicos con lenguaje apropiado para médicos, especialistas o investigadores.
+'''
+}
+# -------- New Part: Load keyword–definition dataset ----------
+kw_file = "/home/mshahidul/readctrl/data/kyw_def_train/kyw_gen_gpt5.json"
+with open(kw_file, "r", encoding="utf-8") as f:
+    definitions_data = json.load(f)
+
+# Build quick lookup: id -> glossary text
+def_map = {}
+for obj in definitions_data:
+    cid = obj.get("id")
+    kwlist = obj.get("medical_keywords", [])
+    defs_str = ""
+    if kwlist:
+        defs_lines = [f"• {d['term']} — {d['definition']}" for d in kwlist]
+        defs_str = "Relevant medical definitions:\n" + "\n".join(defs_lines)
+    def_map[cid] = defs_str
+# --------------------------------------------------------------
+
+path = "/home/mshahidul/readctrl/data/testing_data/multiclinsum_test_es.json"
+out_dir = "/home/mshahidul/readctrl/results/custom_promptsV1"
+os.makedirs(out_dir, exist_ok=True)
+
+if os.path.exists(model_name):
+    out_path = out_dir + f"/temp{temperature}_qwen3-14B_finetuned_with_defs.json"
+else:
+    out_path = out_dir + f"/temp{temperature}_qwen3-14B_base_with_defs.json"
+
+results, completed_keys = [], set()
+if os.path.exists(out_path):
+    with open(out_path, "r", encoding="utf-8") as f:
+        results = json.load(f)
+    for r in results:
+        completed_keys.add(r["fulltext"])
+
+# -------- Load main dataset -----------
+with open(path, "r", encoding="utf-8") as f:
+    dataset = json.load(f)
+dataset = dataset[0:50]
+
+from unsloth import FastLanguageModel
+import torch
+
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name=model_name,
+    max_seq_length=4092,
+    load_in_4bit=False,
+    load_in_8bit=False,
+    full_finetuning=False,
+)
+
+import tqdm
+for item in tqdm.tqdm(dataset):
+    key = item["fulltext"]
+    if key in completed_keys:
+        continue
+    item_id = item["id"]
+    glossary = def_map.get(item_id, "")  # retrieve glossary if exists
+
+    for band in ["easy", "intermediate", "hard"]:
+        # Append definitions below the case text
+        user_content = f"Input text:\n{item['fulltext'].strip()}"
+        # if glossary:
+        #     user_content += "\n\n" + glossary
+
+        messages = [
+            {"role": "system", "content": prompts[band].strip()},
+            {"role": "user", "content": user_content}
+        ]
+
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+
+        inputs = tokenizer(text, return_tensors="pt").to("cuda")
+        input_len = inputs.input_ids.shape[1]
+        length_factors = {"easy": 0.5, "intermediate": 0.8, "hard": 1.1}
+        max_new_tokens = int(min(1200, max(150, input_len * length_factors[band])))
+
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=0.9,
+            top_k=45,
+        )
+        output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+
+        results.append({
+            "id": item_id,
+            "fulltext": item["fulltext"],
+            "band": band,
+            "lang": "es",
+            "synthetic_summary": output_text,
+            "definitions_used": bool(glossary)  # track whether glossary applied
+        })
+
+        completed_keys.add(key)
+        if len(results) % 3 == 0:
+            with open(out_path, "w", encoding="utf-8") as f:
+                json.dump(results, f, ensure_ascii=False, indent=2)
+
+with open(out_path, "w", encoding="utf-8") as f:
+    json.dump(results, f, ensure_ascii=False, indent=2)
+
+
+from notifier import send_notification
+send_notification(
+    "process-complete1507034",
+    f"Finished inference with model {model_name} at temperature {temperature}. Results saved to {out_path}",
+    title="Inference Complete",
+    priority="default",
+    tags="tada"
+)

code/finetune-inference/old/inference_extract_subclaims.py

@@ -0,0 +1,162 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+
+import torch
+from unsloth import FastLanguageModel
+import json
+import tqdm
+
+# -----------------------------
+#  MODEL CACHE
+# -----------------------------
+_model_cache = {"model": None, "tokenizer": None}
+
+def load_finetuned_model(model_path: str):
+    """Load and cache your fine-tuned subclaim extraction model + tokenizer."""
+    if _model_cache["model"] is not None:
+        return _model_cache["model"], _model_cache["tokenizer"]
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_path,
+        max_seq_length=8192,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+    _model_cache["model"], _model_cache["tokenizer"] = model, tokenizer
+    return model, tokenizer
+
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    prompt = f"""
+You are an expert medical annotator. Your task is to extract granular, factual subclaims from medical text.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Instructions:
+1. Read the provided medical text.
+2. Break it into clear, objective, atomic subclaims.
+3. Each subclaim must come directly from the text.
+4. Do not add, guess, or infer information.
+5. Each subclaim should be short, specific, and verifiable.
+6. Return ONLY a Python-style list of strings.
+
+Medical Text:
+{medical_text}
+
+Return your output in JSON list format, like:
+[
+  "subclaim 1",
+  "subclaim 2",
+  ...
+]
+"""
+    return prompt
+
+
+# -----------------------------
+#  INFERENCE FUNCTION
+# -----------------------------
+def infer_subclaims(medical_text: str,
+                    model_path: str,
+                    temperature: float = 0.2) -> str:
+    
+    model, tokenizer = load_finetuned_model(model_path)
+
+    prompt = extraction_prompt(medical_text)
+
+    messages = [{"role": "user", "content": prompt}]
+
+    chat_text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,
+    )
+
+    inputs = tokenizer(chat_text, return_tensors="pt").to("cuda")
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=512,
+            temperature=temperature,
+            top_p=0.9,
+            top_k=10,
+            do_sample=False,
+        )
+
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
+
+    # Remove thinking if model inserts `<think>`
+    if "</think>" in output_text:
+        output_text = output_text.split("</think>")[-1].strip()
+
+    return output_text
+
+
+# -----------------------------
+#  MAIN EXECUTION
+# -----------------------------
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, required=True,
+                        help="Path to the input JSON file containing medical texts.")
+    args = parser.parse_args()
+    INPUT_FILE = args.input_file
+    file_name=os.path.basename(INPUT_FILE).split(".json")[0]
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    MODEL_PATH = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-extraction-8b_ctx"
+
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"extracted_subclaims_{file_name}_en.json")
+
+    # Load input dataset
+    with open(INPUT_FILE, "r") as f:
+        data = json.load(f)
+
+    # Load existing results (resume mode)
+    result = []
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r") as f:
+            result = json.load(f)
+
+    existing_ids = {item["id"] for item in result}
+
+    # --------------------------------------------------------
+    # PROCESS EACH MEDICAL TEXT
+    # --------------------------------------------------------
+    for item in tqdm.tqdm(data):
+        if item["id"] in existing_ids:
+            continue
+
+        medical_text = item.get("fulltext", "")
+
+        extracted = infer_subclaims(
+            medical_text,
+            model_path=MODEL_PATH
+        )
+
+        result.append({
+            "id": item["id"],
+            "medical_text": medical_text,
+            "subclaims": extracted,
+            "summary": item.get("summary", "")
+        })
+
+        # Save every 20 entries
+        if len(result) % 20 == 0:
+            print(f"Saving intermediate results... Total processed: {len(result)}")
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(result, f, indent=4, ensure_ascii=False)
+
+    # Final save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(result, f, indent=4, ensure_ascii=False)
+
+    print("Extraction completed.")

code/finetune-inference/old/inference_extract_subclaims_v2.py

@@ -0,0 +1,179 @@
+import os
+# Set GPU environment variables
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+import torch
+from unsloth import FastLanguageModel
+import json
+import tqdm
+import argparse
+
+
+
+# -----------------------------
+#  MODEL CACHE
+# -----------------------------
+_model_cache = {"model": None, "tokenizer": None}
+
+def load_finetuned_model(model_path: str):
+    """Load and cache your fine-tuned subclaim extraction model + tokenizer."""
+    if _model_cache["model"] is not None:
+        return _model_cache["model"], _model_cache["tokenizer"]
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_path,
+        max_seq_length=8192,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+    _model_cache["model"], _model_cache["tokenizer"] = model, tokenizer
+    return model, tokenizer
+
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    prompt = f"""
+You are an expert medical annotator. Your task is to extract granular, factual subclaims from medical text.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Instructions:
+1. Read the provided medical text.
+2. Break it into clear, objective, atomic subclaims.
+3. Each subclaim must come directly from the text.
+4. Do not add, guess, or infer information.
+5. Each subclaim should be short, specific, and verifiable.
+6. Return ONLY a Python-style list of strings.
+
+Medical Text:
+{medical_text}
+
+Return your output in JSON list format, like:
+[
+  "subclaim 1",
+  "subclaim 2",
+  ...
+]
+"""
+    return prompt
+
+
+# -----------------------------
+#  INFERENCE FUNCTION
+# -----------------------------
+def infer_subclaims(medical_text: str,
+                    model, 
+                    tokenizer,
+                    temperature: float = 0.2) -> list:
+    
+    if not medical_text or medical_text.strip() == "":
+        return []
+
+    prompt = extraction_prompt(medical_text)
+    messages = [{"role": "user", "content": prompt}]
+
+    chat_text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,
+    )
+
+    inputs = tokenizer(chat_text, return_tensors="pt").to("cuda")
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=1024, # Increased to handle potentially longer list outputs
+            temperature=temperature,
+            top_p=0.9,
+            top_k=10,
+            do_sample=False,
+        )
+
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
+
+    # Remove thinking if model inserts `<think>`
+    if "</think>" in output_text:
+        output_text = output_text.split("</think>")[-1].strip()
+
+    # Try to parse as JSON list, return raw text if parsing fails
+    try:
+        # Finding the start and end of the JSON list in case there is conversational filler
+        start_idx = output_text.find('[')
+        end_idx = output_text.rfind(']') + 1
+        if start_idx != -1 and end_idx != -1:
+            return json.loads(output_text[start_idx:end_idx])
+        return output_text
+    except Exception:
+        return output_text
+
+
+# -----------------------------
+#  MAIN EXECUTION
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, required=True,
+                        help="Path to the input JSON file containing medical texts.")
+    args = parser.parse_args()
+    
+    INPUT_FILE = args.input_file
+    file_name = os.path.basename(INPUT_FILE).split(".json")[0]
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    MODEL_PATH = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-extraction-8b_ctx"
+
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"extracted_subclaims_{file_name}_en.json")
+
+    # Load Model once
+    model, tokenizer = load_finetuned_model(MODEL_PATH)
+
+    # Load input dataset
+    with open(INPUT_FILE, "r") as f:
+        data = json.load(f)
+
+    # Load existing results (resume mode)
+    result = []
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r") as f:
+            result = json.load(f)
+
+    existing_ids = {item["id"] for item in result}
+
+    # --------------------------------------------------------
+    # PROCESS EACH MEDICAL TEXT (Fulltext AND Summary)
+    # --------------------------------------------------------
+    for item in tqdm.tqdm(data):
+        if item.get("id") in existing_ids:
+            continue
+
+        # Extract from Fulltext
+        fulltext_content = item.get("fulltext", "")
+        fulltext_subclaims = infer_subclaims(fulltext_content, model, tokenizer)
+
+        # Extract from Summary
+        summary_content = item.get("summary", "")
+        summary_subclaims = infer_subclaims(summary_content, model, tokenizer)
+
+        result.append({
+            "id": item.get("id"),
+            "fulltext": fulltext_content,
+            "fulltext_subclaims": fulltext_subclaims,
+            "summary": summary_content,
+            "summary_subclaims": summary_subclaims,
+            "readability_score": item.get("readability_score", None)
+        })
+
+        # Save intermediate results
+        if len(result) % 20 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(result, f, indent=4, ensure_ascii=False)
+
+    # Final save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(result, f, indent=4, ensure_ascii=False)
+
+    print(f"Extraction completed. Saved to {OUTPUT_FILE}")

code/finetune-inference/old/inference_extract_subclaims_v3.py

@@ -0,0 +1,182 @@
+import os
+# Set GPU environment variables
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+import torch
+from unsloth import FastLanguageModel
+import json
+import tqdm
+import argparse
+
+# -----------------------------
+#  MODEL CACHE
+# -----------------------------
+_model_cache = {"model": None, "tokenizer": None}
+
+def load_finetuned_model(model_path: str):
+    if _model_cache["model"] is not None:
+        return _model_cache["model"], _model_cache["tokenizer"]
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_path,
+        max_seq_length=8192,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+    _model_cache["model"], _model_cache["tokenizer"] = model, tokenizer
+    return model, tokenizer
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    prompt = f"""
+You are an expert medical annotator. Your task is to extract granular, factual subclaims from medical text.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Instructions:
+1. Read the provided medical text.
+2. Break it into clear, objective, atomic subclaims.
+3. Each subclaim must come directly from the text.
+4. Return ONLY a valid JSON list of strings.
+
+Medical Text:
+{medical_text}
+
+Return your output in JSON list format:
+[
+  "subclaim 1",
+  "subclaim 2"
+]
+"""
+    return prompt
+
+# -----------------------------
+#  INFERENCE FUNCTION WITH REPAIR
+# -----------------------------
+def infer_subclaims(medical_text: str, model, tokenizer, temperature: float = 0.2, max_tokens: int = 2048) -> list:
+    if not medical_text or medical_text.strip() == "":
+        return []
+
+    prompt = extraction_prompt(medical_text)
+    messages = [{"role": "user", "content": prompt}]
+
+    chat_text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+    )
+
+    inputs = tokenizer(chat_text, return_tensors="pt").to("cuda")
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=max_tokens, # Increased default
+            temperature=temperature,
+            do_sample=False,
+        )
+
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
+
+    # Remove reasoning/thinking if present
+    if "</think>" in output_text:
+        output_text = output_text.split("</think>")[-1].strip()
+
+    # Attempt to parse
+    try:
+        start_idx = output_text.find('[')
+        end_idx = output_text.rfind(']') + 1
+        if start_idx != -1 and end_idx != -1:
+            parsed = json.loads(output_text[start_idx:end_idx])
+            if isinstance(parsed, list):
+                return parsed
+        return [output_text] # Wrap in list if it's just raw text
+    except Exception:
+        return [output_text]
+
+# -----------------------------
+#  MAIN EXECUTION
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, required=True)
+    args = parser.parse_args()
+    
+    INPUT_FILE = args.input_file
+    file_name = os.path.basename(INPUT_FILE).split(".json")[0]
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    MODEL_PATH = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-extraction-8b_ctx"
+
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"extracted_subclaims_{file_name}_en.json")
+
+    model, tokenizer = load_finetuned_model(MODEL_PATH)
+
+    # Load input dataset
+    with open(INPUT_FILE, "r") as f:
+        data = json.load(f)
+
+    # Load existing results
+    result = []
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r") as f:
+            result = json.load(f)
+
+    # Convert results to a dict for easy lookup/update
+    processed_data = {item["id"]: item for item in result}
+
+    for item in tqdm.tqdm(data):
+        item_id = item.get("id")
+        existing_entry = processed_data.get(item_id)
+
+        # CHECK LOGIC: 
+        # If entry exists and subclaims are already valid lists, we skip.
+        # If they are strings or missing, we re-run with higher tokens.
+        
+        # 1. Check Fulltext Subclaims
+        fulltext_needs_update = (
+            not existing_entry or 
+            not isinstance(existing_entry.get("fulltext_subclaims"), list) or
+            len(existing_entry.get("fulltext_subclaims", [])) == 0
+        )
+        
+        if fulltext_needs_update:
+            f_sub = infer_subclaims(item.get("fulltext", ""), model, tokenizer, max_tokens=3072)
+        else:
+            f_sub = existing_entry["fulltext_subclaims"]
+
+        # 2. Check Summary Subclaims
+        summary_needs_update = (
+            not existing_entry or 
+            not isinstance(existing_entry.get("summary_subclaims"), list) or
+            len(existing_entry.get("summary_subclaims", [])) == 0
+        )
+        
+        if summary_needs_update:
+            s_sub = infer_subclaims(item.get("summary", ""), model, tokenizer, max_tokens=2048)
+        else:
+            s_sub = existing_entry["summary_subclaims"]
+
+        # Update or Append
+        new_entry = {
+            "id": item_id,
+            "fulltext": item.get("fulltext", ""),
+            "fulltext_subclaims": f_sub,
+            "summary": item.get("summary", ""),
+            "summary_subclaims": s_sub,
+            "readability_score": item.get("readability_score", None)
+        }
+        processed_data[item_id] = new_entry
+
+        # Intermediate save
+        if len(processed_data) % 20 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(list(processed_data.values()), f, indent=4, ensure_ascii=False)
+
+    # Final save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(list(processed_data.values()), f, indent=4, ensure_ascii=False)
+
+    print(f"Refinement completed. Total records: {len(processed_data)}")

code/finetune-inference/old/nemotran_inference.py

@@ -0,0 +1,174 @@
+import os
+import json
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+
+import os
+import json
+import tqdm
+import argparse
+import torch
+from unsloth import FastLanguageModel
+
+# -----------------------------
+#  UNSLOTH MODEL CONFIGURATION
+# -----------------------------
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/nemotron-3-nano-30b-a3b_subclaims-support-check-8b_ctx_v2-bf16"
+max_seq_length = 2048 # Adjusted for medical text + reasoning context
+dtype = None # Auto-detection for A100 (will likely use bfloat16)
+load_in_4bit = True # To fit 32B model comfortably on A100
+
+# Load model and tokenizer natively
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name = MODEL_PATH,
+    max_seq_length = max_seq_length,
+    dtype = dtype,
+    load_in_4bit = load_in_4bit,
+    trust_remote_code = True,
+)
+
+# Enable 2x faster native inference
+FastLanguageModel.for_inference(model)
+
+# -----------------------------
+#  VERIFICATION PROMPT
+# -----------------------------
+def inference_prompt(text, subclaim):
+    # This remains the same as your clinical evidence auditor prompt
+    return f"""You are a clinical evidence auditor. Your evaluation must be based STRICTLY and ONLY on the provided medical text. 
+
+### MANDATORY GROUNDING RULES:
+1. NO OUTSIDE KNOWLEDGE: Do not use your internal medical knowledge. Even if a subclaim is "common sense" in medicine, if it is not explicitly in the TEXT, it is 'not_supported'.
+2. NO LOGICAL LEAPS: Do not bridge gaps in logic. (e.g., If the text mentions "high blood sugar" but not the word "diabetes", you cannot support a claim of "diabetes").
+3. EXACT NUMERICAL MATCHING: Any doses (e.g., 500mg), frequencies (e.g., twice daily), or durations (e.g., 10 days) mentioned in the subclaim must match the text perfectly. If they are missing or different in the text, label as 'not_supported'.
+4. DEFAULT TO NOT SUPPORTED: If the text is vague, ambiguous, or only suggests a possibility, you MUST choose 'not_supported'. 
+5. CLOSED-WORLD REALITY: Treat the TEXT as the only information that exists in the world.
+
+### Medical Text:
+{text}
+
+### Subclaim:
+{subclaim}
+
+Output exactly one word ('supported' or 'not_supported') based on the strict rules above:"""
+
+# -----------------------------
+#  VERIFICATION LOGIC (UNSLOTH VERSION)
+# -----------------------------
+def check_support(text: str, subclaim: str, error_log=None) -> str:
+    if not text or not subclaim:
+        return "not_supported"
+
+    prompt_content = inference_prompt(text, subclaim)
+    
+    # Format for Chat Template (assuming Qwen3 uses IM_START/IM_END)
+    messages = [{"role": "user", "content": prompt_content}]
+    inputs = tokenizer.apply_chat_template(
+        messages,
+        tokenize = True,
+        add_generation_prompt = True,
+        return_tensors = "pt",
+    ).to("cuda")
+
+    try:
+        # Inference using the same parameters as your API call
+        outputs = model.generate(
+            input_ids = inputs,
+            max_new_tokens = 512, # Kept from your max_tokens=512
+            temperature = 0.1,     # Kept from your temperature=0.1
+            use_cache = True,
+        )
+        
+        # Extract response and handle thinking tokens if present
+        res = tokenizer.batch_decode(outputs[:, inputs.shape[1]:], skip_special_tokens=True)[0]
+        res = res.strip().lower()
+
+        if "</think>" in res:
+            res = res.split("</think>")[1].strip().lower()
+
+        if "not_supported" in res:
+            return "not_supported"
+        elif "supported" in res:
+            return "supported"
+        elif "refuted" in res:
+            return "refuted"
+        else:
+            return "not_supported"
+
+    except Exception as e:
+        if error_log is not None:
+            error_details = {"subclaim": subclaim, "error_msg": str(e), "type": "LOCAL_INFERENCE_ERROR"}
+            error_log.append(error_details)
+        return "not_supported"
+
+# -----------------------------
+#  MAIN (Processing logic remains largely identical)
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/model_validity_check/subclaims_support_validity_check_gt_gpt5(1-5).json")
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/concise_complete_attr_testing")
+    parser.add_argument("--start_index", type=int, default=0)
+    parser.add_argument("--end_index", type=int, default=-1)
+
+    args = parser.parse_args()
+
+    INPUT_FILE = args.input_file
+    SAVE_FOLDER = args.save_folder
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    with open(INPUT_FILE, "r") as f:
+        all_data = json.load(f)
+
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    data_slice = all_data[start:min(end, total_len)]
+
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"evaluated_metrics_{start}_{end}_nemotran-30B.json")
+   
+    processed_results = []
+    if os.path.exists(OUTPUT_FILE):
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                processed_results = json.load(f)
+        except:
+            processed_results = []
+    
+    processed_ids = {item['medical_text'] for item in processed_results}
+    global_error_log = []
+
+    pbar = tqdm.tqdm(data_slice)
+    
+    for item in pbar:
+        text = item.get('full_text', '')
+        if text in processed_ids: continue # Simple skip logic for resume
+            
+        subclaims = item.get('dat', {}).get('dat', [])
+        
+        for subclaim_obj in subclaims:
+            subclaim_text = subclaim_obj.get('subclaim', '')
+            label_gt = subclaim_obj.get('status', 'not_supported').strip().lower()
+            
+            label_gen = check_support(text, subclaim_text, error_log=global_error_log)
+            
+            correctness = (label_gen == label_gt)
+            
+            result_entry = {
+                "medical_text": text,
+                "subclaim": subclaim_text,
+                "label_gt": label_gt,
+                "label_gen": label_gen,
+                "correctness": correctness
+            }
+            processed_results.append(result_entry)
+            
+        # Intermediate Save
+        with open(OUTPUT_FILE, "w") as f:
+            json.dump(processed_results, f, indent=2, ensure_ascii=False)
+
+    # Final Save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(processed_results, f, indent=2, ensure_ascii=False)

code/finetune-inference/old/prompt_generate.py

@@ -0,0 +1,254 @@
+ALL_PROMPTS = {
+    "en": {
+        "B1": """You are a summarization assistant. Your single most important goal is to rewrite medical text for a first-grade reading level (ages 5-7, FKGL 1.0-4.0). Simplicity is more important than detail.
+
+Core Mandate:
+- TARGET AUDIENCE: A 6-year-old child.
+- PRIMARY GOAL: Extreme simplicity. If you must choose between accuracy of detail and simplicity, ALWAYS choose simplicity.
+
+Strict Rules You Must Follow:
+- SENTENCE LENGTH: Keep almost all sentences under 10 words. Use very short, simple sentences.
+- VOCABULARY: Use only very common, everyday words that a first-grader would know. Avoid any medical or scientific terms. Instead of 'femur', say 'thigh bone'. Instead of 'benign', say 'not harmful'.
+- TONE: Be very gentle, calm, and reassuring. Like a kind doctor explaining something to a small child.
+- STRUCTURE: Use short paragraphs, often just one or two sentences long.
+- FOCUS: Only mention the most important one or two points from the original text. Omit all other details.
+
+- Never use emojis.
+- Do not explain pronunciation.
+- DO NOT use any medical jargon.
+""",
+    "B2": """You are a summarization assistant trained to rewrite medical summaries for a middle school reading level (ages 11–14, FKGL 6.0–9.0). Your goal is clarity for a teenager with a basic understanding of biology.
+
+Core Mandate:
+- TARGET AUDIENCE: A 14-year-old in a 9th-grade biology class.
+- PRIMARY GOAL: Clarity and straightforward explanation.
+
+Strict Rules You Must Follow:
+- SENTENCE LENGTH: Vary sentence length, but aim for an average of 12-18 words. Avoid long, complex sentences.
+- VOCABULARY: You can use basic medical terms (e.g., 'biopsy', 'cells', 'tumor'), but you MUST explain them in simple terms immediately. For example: "A biopsy, which is when a small piece of tissue is taken for testing...".
+- TONE: Be empathetic but direct. Use an educational and informative tone, like a science teacher.
+- STRUCTURE: Organize the summary into logical paragraphs. You can use simple headings if it helps clarity (e.g., "What They Found," "What It Means").
+- FOCUS: Summarize the main findings and their implications. Omit minor or highly technical details.
+
+- Never use emojis.
+- Do not explain pronunciation.
+""",
+    "B3": """You are a summarization assistant trained to rewrite medical summaries for an educated, non-medical adult (ages 17+, FKGL 12.0+). Your goal is to be precise, comprehensive, and clear for a college-level reader.
+
+Core Mandate:
+- TARGET AUDIENCE: A curious college student or adult with no medical training.
+- PRIMARY GOAL: Precision and structured clarity.
+
+Strict Rules You Must Follow:
+- SENTENCE LENGTH: Use clear, well-constructed sentences. Complex sentences are acceptable if they enhance clarity and precision.
+- VOCABULARY: Use correct medical terminology. You can assume the reader can understand terms from context or look them up, but for very specialized terms, provide a brief parenthetical explanation. For example: "...showed evidence of hyperplasia (an increase in the number of cells)."
+- TONE: Maintain a professional, empathetic, and respectful tone. Be authoritative but not clinical or cold.
+- STRUCTURE: Provide a detailed and structured summary. Use headings to organize information, such as "Background," "Key Findings," "Clinical Interpretation," and "Next Steps."
+- FOCUS: Be comprehensive and faithful to the source summary. Include important details, test results, and differential diagnoses mentioned in the source.
+
+- Never use emojis.
+- Do not explain pronunciation.
+"""
+    },
+    "es": {
+        "B1": """Eres un asistente de resumen. Tu único y más importante objetivo es reescribir texto médico para un nivel de lectura de primer grado (edades 5-7). La simplicidad es más importante que el detalle.
+
+Mandato Principal:
+- PÚBLICO OBJETIVO: Un niño de 6 años.
+- OBJETIVO PRIMARIO: Simplicidad extrema. Si debes elegir entre la precisión del detalle y la simplicidad, SIEMPRE elige la simplicidad.
+
+Reglas Estrictas que Debes Seguir:
+- IDIOMA: El resumen DEBE estar escrito en español.
+- LONGITUD DE LA ORACIÓN: Casi todas las oraciones deben tener menos de 10 palabras. Usa frases muy cortas y simples.
+- VOCABULARIO: Usa solo palabras cotidianas y muy comunes que un niño de primer grado conocería. Evita cualquier término médico o científico. En lugar de 'fémur', di 'hueso del muslo'. En lugar de 'benigno', di 'que no es dañino'.
+- TONO: Sé muy gentil, calmado y tranquilizador. Como un doctor amable explicándole algo a un niño pequeño.
+- ESTRUCTURA: Usa párrafos cortos, a menudo de solo una o dos oraciones.
+- ENFOQUE: Menciona solo el punto más importante o los dos puntos más importantes del texto original. Omite todos los demás detalles.
+
+- Nunca uses emojis.
+- No expliques la pronunciación.
+- NO uses jerga médica.
+""",
+        "B2": """Eres un asistente de resumen entrenado para reescribir resúmenes médicos para un nivel de lectura de secundaria (edades 11–14). Tu objetivo es la claridad para un adolescente con conocimientos básicos de biología.
+
+Mandato Principal:
+- PÚBLICO OBJETIVO: Un estudiante de 14 años en una clase de biología de secundaria.
+- OBJETIVO PRIMARIO: Claridad y explicación directa.
+
+Reglas Estrictas que Debes Seguir:
+- IDIOMA: El resumen DEBE estar escrito en español.
+- LONGITUD DE LA ORACIÓN: Varía la longitud de las oraciones, pero busca un promedio de 12-18 palabras. Evita las oraciones largas y complejas.
+- VOCABULARIO: Puedes usar términos médicos básicos (ej., 'biopsia', 'células', 'tumor'), pero DEBES explicarlos en términos sencillos inmediatamente. Por ejemplo: "Una biopsia, que es cuando se toma un pequeño trozo de tejido para analizarlo...".
+- TONO: Sé empático pero directo. Usa un tono educativo e informativo, como un profesor de ciencias.
+- ESTRUCTURA: Organiza el resumen en párrafos lógicos. Puedes usar encabezados simples si ayuda a la claridad (ej., "Lo que Encontraron," "Qué Significa").
+- ENFOQUE: Resume los hallazgos principales y sus implicaciones. Omite detalles menores o muy técnicos.
+
+- Nunca uses emojis.
+- No expliques la pronunciación.
+""",
+        "B3": """Eres un asistente de resumen entrenado para reescribir resúmenes médicos para un adulto educado no médico (edades 17+). Tu objetivo es ser preciso, completo y claro para un lector de nivel universitario.
+
+Mandato Principal:
+- PÚBLICO OBJETIVO: Un estudiante universitario o un adulto curioso sin formación médica.
+- OBJETIVO PRIMARIO: Precisión y claridad estructurada.
+
+Reglas Estrictas que Debes Seguir:
+- IDIOMA: El resumen DEBE estar escrito en español.
+- LONGITUD DE LA ORACIÓN: Usa oraciones claras y bien construidas. Las oraciones complejas son aceptables si mejoran la claridad y la precisión.
+- VOCABULARIO: Usa la terminología médica correcta. Puedes asumir que el lector puede entender los términos por el contexto o buscarlos, pero para términos muy especializados, proporciona una breve explicación entre paréntesis. Por ejemplo: "...mostró evidencia de hiperplasia (un aumento en el número de células)."
+- TONO: Mantén un tono profesional, empático y respetuoso. Sé autoritario pero no clínico o frío.
+- ESTRUCTURA: Proporciona un resumen detallado y estructurado. Usa encabezados para organizar la información, como "Contexto," "Hallazgos Clave," "Interpretación Clínica," y "Próximos Pasos."
+- ENFOQUE: Sé completo y fiel al resumen original. Incluye detalles importantes, resultados de pruebas y diagnósticos diferenciales mencionados en la fuente.
+
+- Nunca uses emojis.
+- No expliques la pronunciación.
+"""
+    },
+"fr": {
+    "B1": """Vous êtes un assistant de résumé. Votre unique et plus important objectif est de réécrire un texte médical pour un niveau de lecture de cours préparatoire (âges 5-7). La simplicité est plus importante que le détail.
+
+Mandat Principal :
+- PUBLIC CIBLE : Un enfant de 6 ans.
+- OBJECTIF PRINCIPAL : Simplicité extrême. Si vous devez choisir entre la précision des détails et la simplicité, choisissez TOUJOURS la simplicité.
+
+Règles Strictes à Suivre Impérativement :
+- LANGUE : Le résumé DOIT être rédigé en français.
+- LONGUEUR DES PHRASES : Presque toutes les phrases doivent faire moins de 10 mots. Utilisez des phrases très courtes et simples.
+- VOCABULAIRE : Utilisez uniquement des mots très courants et quotidiens qu'un enfant de cet âge connaîtrait. Évitez tout terme médical ou scientifique. Au lieu de 'fémur', dites 'l'os de la cuisse'. Au lieu de 'bénin', dites 'pas dangereux'.
+- TON : Soyez très doux, calme et rassurant. Comme un médecin bienveillant qui explique quelque chose à un jeune enfant.
+- STRUCTURE : Utilisez des paragraphes courts, souvent composés d'une ou deux phrases seulement.
+- ENFOQUE : Mentionnez uniquement le ou les deux points les plus importants du texte original. Omettez tous les autres détails.
+
+- N'utilisez jamais d'emojis.
+- N'expliquez pas la prononciation.
+- N'utilisez AUCUN jargon médical.
+""",
+    "B2": """Vous êtes un assistant de résumé entraîné à réécrire des résumés médicaux pour un niveau de lecture de collège (âges 11–14). Votre objectif est la clarté pour un adolescent ayant une compréhension de base de la biologie.
+
+Mandat Principal :
+- PUBLIC CIBLE : Un adolescent de 14 ans en classe de biologie au collège.
+- OBJECTIF PRINCIPAL : Clarté et explication directe.
+
+Règles Strictes à Suivre Impérativement :
+- LANGUE : Le résumé DOIT être rédigé en français.
+- LONGUEUR DES PHRASES : Variez la longueur des phrases, mais visez une moyenne de 12-18 mots. Évitez les phrases longues et complexes.
+- VOCABULAIRE : Vous pouvez utiliser des termes médicaux de base (ex: 'biopsie', 'cellules', 'tumeur'), mais vous DEVEZ les expliquer en termes simples immédiatement. Par exemple : "Une biopsie, c'est-à-dire quand on prélève un petit morceau de tissu pour l'analyser...".
+- TON : Soyez empathique mais direct. Adoptez un ton pédagogique et informatif, comme un professeur de sciences.
+- STRUCTURE : Organisez le résumé en paragraphes logiques. Vous pouvez utiliser des titres simples si cela améliore la clarté (ex: "Ce qu'ils ont trouvé", "Ce que cela signifie").
+- ENFOQUE : Résumez les principales observations et leurs implications. Omettez les détails mineurs ou très techniques.
+
+- N'utilisez jamais d'emojis.
+- N'expliquez pas la prononciation.
+""",
+    "B3": """Vous êtes un assistant de résumé entraîné à réécrire des résumés médicaux pour un adulte éduqué non-médecin (âges 17+). Votre objectif est d'être précis, complet et clair pour un lecteur de niveau universitaire.
+
+Mandat Principal :
+- PUBLIC CIBLE : Un étudiant ou un adulte curieux sans formation médicale.
+- OBJECTIF PRINCIPAL : Précision et clarté structurée.
+
+Règles Strictes à Suivre Impérativement :
+- LANGUE : Le résumé DOIT être rédigé en français.
+- LONGUEUR DES PHRASES : Utilisez des phrases claires et bien construites. Les phrases complexes sont acceptables si elles améliorent la clarté et la précision.
+- VOCABULAIRE : Utilisez la terminologie médicale correcte. Vous pouvez supposer que le lecteur peut comprendre les termes par le contexte ou les rechercher, mais pour les termes très spécialisés, fournissez une brève explication entre parenthèses. Par exemple : "...montrait des signes d'hyperplasie (une augmentation du nombre de cellules)."
+- TON : Maintenez un ton professionnel, empathique et respectueux. Soyez directif mais ni clinique ni froid.
+- STRUCTURE : Fournissez un résumé détaillé et structuré. Utilisez des titres pour organiser l'information, tels que "Contexte", "Principales Observations", "Interprétation Clinique" et "Prochaines Étapes".
+- ENFOQUE : Soyez complet et fidèle au résumé source. Incluez les détails importants, les résultats des tests et les diagnostics différentiels mentionnés dans la source.
+
+- N'utilisez jamais d'emojis.
+- N'expliquez pas la prononciation.
+"""
+},
+
+"pt": {
+    "B1": """Você é um assistente de resumo. O seu único e mais importante objetivo é reescrever textos médicos para um nível de leitura da primeira série (idades 5-7). A simplicidade é mais importante que os detalhes.
+
+Mandato Principal:
+- PÚBLICO-ALVO: Uma criança de 6 anos.
+- OBJETIVO PRINCIPAL: Simplicidade extrema. Se tiver que escolher entre a precisão dos detalhes e a simplicidade, ESCOLHA SEMPRE a simplicidade.
+
+Regras Rígidas que Você Deve Seguir:
+- IDIOMA: O resumo DEVE ser escrito em português.
+- COMPRIMENTO DAS FRASES: Quase todas as frases devem ter menos de 10 palavras. Use frases muito curtas e simples.
+- VOCABULÁRIO: Use apenas palavras quotidianas e muito comuns que uma criança da primeira série conheceria. Evite qualquer termo médico ou científico. Em vez de 'fêmur', diga 'o osso da coxa'. Em vez de 'benigno', diga 'que não faz mal'.
+- TOM: Seja muito gentil, calmo e tranquilizador. Como um médico amável a explicar algo a uma criança pequena.
+- ESTRUTURA: Use parágrafos curtos, muitas vezes com apenas uma ou duas frases.
+- FOCO: Mencione apenas um ou dois dos pontos mais importantes do texto original. Omita todos os outros detalhes.
+
+- Nunca use emojis.
+- Não explique a pronúncia.
+- NÃO use NENHUM jargão médico.
+""",
+    "B2": """Você é um assistente de resumo treinado para reescrever resumos médicos para um nível de leitura do ensino fundamental II (idades 11–14). O seu objetivo é a clareza para um adolescente com conhecimentos básicos de biologia.
+
+Mandato Principal:
+- PÚBLICO-ALVO: Um adolescente de 14 anos numa aula de biologia.
+- OBJETIVO PRINCIPAL: Clareza e explicação direta.
+
+Regras Rígidas que Você Deve Seguir:
+- IDIOMA: O resumo DEVE ser escrito em português.
+- COMPRIMENTO DAS FRASES: Varie o comprimento das frases, mas procure uma média de 12 a 18 palavras. Evite frases longas e complexas.
+- VOCABULÁRIO: Pode usar termos médicos básicos (ex: 'biópsia', 'células', 'tumor'), mas você DEVE explicá-los em termos simples imediatamente. Por exemplo: "Uma biópsia, que é quando um pequeno pedaço de tecido é retirado para ser analisado...".
+- TOM: Seja empático, mas direto. Use um tom educativo e informativo, como um professor de ciências.
+- ESTRUTURA: Organize o resumo em parágrafos lógicos. Pode usar títulos simples se isso ajudar na clareza (ex: "O que eles encontraram", "O que isso significa").
+- FOCO: Resuma os principais achados e as suas implicações. Omita detalhes menores ou muito técnicos.
+
+- Nunca use emojis.
+- Não explique a pronúncia.
+""",
+    "B3": """Você é um assistente de resumo treinado para reescrever resumos médicos para um adulto instruído, mas sem formação médica (idades 17+). O seu objetivo é ser preciso, abrangente e claro para um leitor de nível universitário.
+
+Mandato Principal:
+- PÚBLICO-ALVO: Um estudante universitário ou adulto curioso sem formação médica.
+- OBJETIVO PRINCIPAL: Precisão e clareza estruturada.
+
+Regras Rígidas que Você Deve Seguir:
+- IDIOMA: O resumo DEVE ser escrito em português.
+- COMPRIMENTO DAS FRASES: Use frases claras e bem construídas. Frases complexas são aceitáveis se melhorarem a clareza e a precisão.
+- VOCABULÁRIO: Use a terminologia médica correta. Pode assumir que o leitor consegue entender os termos pelo contexto ou pesquisá-los, mas para termos muito especializados, forneça uma breve explicação entre parênteses. Por exemplo: "...mostrou evidência de hiperplasia (um aumento no número de células)."
+- TOM: Mantenha um tom profissional, empático e respeitoso. Seja confiante, mas não clínico ou frio.
+- ESTRUTURA: Forneça um resumo detalhado e estruturado. Use títulos para organizar a informação, como "Contexto", "Principais Achados", "Interpretação Clínica" e "Próximos Passos".
+- FOCO: Seja abrangente e fiel ao resumo original. Inclua detalhes importantes, resultados de testes e diagnósticos diferenciais mencionados na fonte.
+
+- Nunca use emojis.
+- Não explique a pronúncia.
+"""
+}
+
+}
+USER_PROMPT_TEMPLATES = {
+    "en": """Please rewrite the following expert summary for the specified target audience. Use the full article for context if needed.
+**Full Article Context:**
+{article}
+**Expert Summary to Rewrite:**
+{gold_summary}
+""",
+    "es": """Por favor, reescribe el siguiente resumen de experto para el público objetivo especificado. Usa el artículo completo como contexto si es necesario.
+**Contexto del Artículo Completo:**
+{article}
+**Resumen de Experto a Reescribir:**
+{gold_summary}
+""",
+    "fr": """Veuillez réécrire le résumé d'expert suivant pour le public cible spécifié. Utilisez l'article complet comme contexte si nécessaire.
+**Contexte de l'Article Complet :**
+{article}
+**Résumé d'Expert à Réécrire :**
+{gold_summary}
+""",
+    "pt": """Por favor, reescreva o seguinte resumo de especialista para o público-alvo especificado. Use o artigo completo como contexto, se necessário.
+**Contexto do Artigo Completo:**
+{article}
+**Resumo do Especialista a Ser Reescrito:**
+{gold_summary}
+"""
+}
+
+def generate_prompt(article, gold_summary, band, lang):
+    """Call an OpenAI model to generate a synthetic summary for a given readability band and language."""
+    prompts_for_lang = ALL_PROMPTS.get(lang)
+    user_prompt_template = USER_PROMPT_TEMPLATES.get(lang)
+    if not prompts_for_lang or not user_prompt_template:
+        raise ValueError(f"No prompts available for language: {lang}")
+    
+    system_prompt = prompts_for_lang[band]
+    user_prompt = user_prompt_template.format(article=article, gold_summary=gold_summary)
+    return system_prompt + "\n" + user_prompt

code/finetune-inference/old/statistics.ipynb

@@ -0,0 +1,400 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1408eea5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "with open('/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json', 'r') as f:\n",
+    "    data_item = json.load(f)\n",
+    "data = []\n",
+    "for item in data_item:\n",
+    "    attribution=item['attribution']['accuracy']\n",
+    "    data.append(attribution)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c706e713",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy import stats\n",
+    "\n",
+    "# Example data list\n",
+    "# data = [12, 15, 14, 18, 19, 17, 21]\n",
+    "\n",
+    "# Convert to a pandas Series for convenience\n",
+    "s = pd.Series(data)\n",
+    "\n",
+    "# --- 1. Basic statistics ---\n",
+    "summary = s.describe()\n",
+    "print(\"Basic statistics:\")\n",
+    "print(summary)\n",
+    "\n",
+    "# Extra metrics\n",
+    "print(\"\\nAdditional info:\")\n",
+    "print(f\"Variance: {s.var():.2f}\")\n",
+    "print(f\"Skewness: {s.skew():.2f}\")\n",
+    "print(f\"Kurtosis: {s.kurt():.2f}\")\n",
+    "print(f\"Mode: {s.mode().tolist()}\")\n",
+    "\n",
+    "# --- 2. Visualization ---\n",
+    "plt.figure(figsize=(8, 5))\n",
+    "sns.histplot(s, bins=10, kde=True, color='skyblue', edgecolor='black')\n",
+    "plt.title(\"Distribution curve of data\")\n",
+    "plt.xlabel(\"Value\")\n",
+    "plt.ylabel(\"Frequency\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "860aff4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "s = pd.Series(data)  # sample data with an outlier\n",
+    "\n",
+    "# Compute IQR boundaries\n",
+    "Q1 = s.quantile(0.25)\n",
+    "Q3 = s.quantile(0.75)\n",
+    "IQR = Q3 - Q1\n",
+    "\n",
+    "lower_lim = Q1 - 1.5 * IQR\n",
+    "upper_lim = Q3 + 1.5 * IQR\n",
+    "\n",
+    "cleaned = s[(s >= lower_lim) & (s <= upper_lim)]\n",
+    "\n",
+    "print(\"Cleaned data:\")\n",
+    "print(len(cleaned.tolist()))\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "sns.boxplot(x=s, color=\"lightblue\")\n",
+    "plt.title(\"Before cleaning\")\n",
+    "plt.show()\n",
+    "\n",
+    "sns.boxplot(x=cleaned, color=\"lightgreen\")\n",
+    "plt.title(\"After IQR cleaning\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b1f16b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from scipy import stats\n",
+    "\n",
+    "z_scores = np.abs(stats.zscore(s))\n",
+    "threshold = 3  # commonly used threshold\n",
+    "cleaned_z = s[z_scores < threshold]\n",
+    "print(len(cleaned_z.tolist()))\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "print(\"Cleaned data (Z-score method):\")\n",
+    "sns.boxplot(x=s, color=\"lightblue\")\n",
+    "plt.title(\"Before cleaning\")\n",
+    "plt.show()\n",
+    "\n",
+    "sns.boxplot(x=cleaned_z, color=\"lightgreen\")\n",
+    "plt.title(\"After Z-score cleaning\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4394d44c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e24c8c2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f97f821e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "def analyze_doclens_results(file_path):\n",
+    "    \"\"\"\n",
+    "    Loads, parses, and analyzes the DOCLENS evaluation results from a JSON file.\n",
+    "\n",
+    "    Args:\n",
+    "        file_path (str): The path to the JSON results file.\n",
+    "\n",
+    "    Returns:\n",
+    "        pandas.DataFrame: A DataFrame with the aggregated mean scores.\n",
+    "    \"\"\"\n",
+    "    # Load the entire JSON file\n",
+    "    try:\n",
+    "        with open(file_path, 'r', encoding='utf-8') as f:\n",
+    "            data = json.load(f)\n",
+    "    except FileNotFoundError:\n",
+    "        print(f\"Error: The file '{file_path}' was not found.\")\n",
+    "        return None\n",
+    "    except json.JSONDecodeError:\n",
+    "        print(f\"Error: The file '{file_path}' is not a valid JSON file.\")\n",
+    "        return None\n",
+    "\n",
+    "    # Parse the nested data into a flat list of dictionaries\n",
+    "    parsed_data = []\n",
+    "    for record in data:\n",
+    "        record_id = record.get(\"id\")\n",
+    "        version = record.get(\"version\")\n",
+    "        \n",
+    "        # Extract accuracy scores safely\n",
+    "        completeness_acc = record.get(\"completeness\", {}).get(\"accuracy\", 0)\n",
+    "        conciseness_acc = record.get(\"conciseness\", {}).get(\"accuracy\", 0)\n",
+    "        attribution_acc = record.get(\"attribution\", {}).get(\"accuracy\", 0)\n",
+    "\n",
+    "        parsed_data.append({\n",
+    "            \"id\": record_id,\n",
+    "            \"version\": version,\n",
+    "            \"completeness\": completeness_acc,\n",
+    "            \"conciseness\": conciseness_acc,\n",
+    "            \"attribution\": attribution_acc\n",
+    "        })\n",
+    "\n",
+    "    # Create a pandas DataFrame\n",
+    "    df = pd.DataFrame(parsed_data)\n",
+    "\n",
+    "    # Calculate the mean scores for each version\n",
+    "    # The order is specified to ensure 'easy', 'intermediate', 'hard' are plotted correctly\n",
+    "    version_order = ['easy', 'intermediate', 'hard']\n",
+    "    df['version'] = pd.Categorical(df['version'], categories=version_order, ordered=True)\n",
+    "    \n",
+    "    agg_results = df.groupby('version')[['completeness', 'conciseness', 'attribution']].mean().reset_index()\n",
+    "\n",
+    "    print(\"--- Aggregated Mean Scores ---\")\n",
+    "    print(agg_results.to_string(index=False))\n",
+    "    \n",
+    "    return agg_results\n",
+    "\n",
+    "def visualize_results(df):\n",
+    "    \"\"\"\n",
+    "    Generates and saves bar charts to visualize the aggregated results.\n",
+    "    \"\"\"\n",
+    "    if df is None or df.empty:\n",
+    "        print(\"Cannot visualize results. DataFrame is empty.\")\n",
+    "        return\n",
+    "\n",
+    "    sns.set_style(\"whitegrid\")\n",
+    "    fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharey=True)\n",
+    "    fig.suptitle('Average Evaluation Metrics Across Summary Versions', fontsize=16)\n",
+    "\n",
+    "    # Plot Completeness\n",
+    "    sns.barplot(ax=axes[0], x='version', y='completeness', data=df, palette='Blues_d')\n",
+    "    axes[0].set_title('Completeness (Claim Recall)')\n",
+    "    axes[0].set_xlabel('Summary Version')\n",
+    "    axes[0].set_ylabel('Average Accuracy (%)')\n",
+    "\n",
+    "    # Plot Conciseness\n",
+    "    sns.barplot(ax=axes[1], x='version', y='conciseness', data=df, palette='Greens_d')\n",
+    "    axes[1].set_title('Conciseness (Claim Precision)')\n",
+    "    axes[1].set_xlabel('Summary Version')\n",
+    "    axes[1].set_ylabel('')\n",
+    "\n",
+    "    # Plot Attribution\n",
+    "    sns.barplot(ax=axes[2], x='version', y='attribution', data=df, palette='Oranges_d')\n",
+    "    axes[2].set_title('Attribution')\n",
+    "    axes[2].set_xlabel('Summary Version')\n",
+    "    axes[2].set_ylabel('')\n",
+    "    \n",
+    "    # Improve layout and save the figure\n",
+    "    plt.tight_layout(rect=[0, 0, 1, 0.96])\n",
+    "    plt.savefig(\"doclens_evaluation_summary.png\", dpi=300)\n",
+    "    print(\"\\nChart saved as 'doclens_evaluation_summary.png'\")\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "# --- Main Execution ---\n",
+    "# Replace 'your_results_file.json' with the actual path to your file\n",
+    "results_file = '/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json' \n",
+    "aggregated_data = analyze_doclens_results(results_file)\n",
+    "\n",
+    "if aggregated_data is not None:\n",
+    "    visualize_results(aggregated_data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5afb981",
+   "metadata": {},
+   "source": [
+    "## Eliminate dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "b29bcf30",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rejected 15 items due to low attribution.\n",
+      "Rejected 9 additional items due to incorrect completeness trend.\n",
+      "\n",
+      "--- Filtering Summary ---\n",
+      "Total unique items analyzed: 100\n",
+      "Items kept (High Quality): 76\n",
+      "Items rejected (Low Quality): 24\n",
+      "Saved data to '/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B_clean.json'\n",
+      "Saved data to '/home/mshahidul/readctrl/results/dataset_quality_check/rejected_dataset.json'\n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "import pandas as pd\n",
+    "\n",
+    "def filter_low_quality_data(file_path, attribution_threshold=80.0, completeness_trend_check=True):\n",
+    "    \"\"\"\n",
+    "    Loads DOCLENS results, filters out low-quality data, and returns clean/rejected data.\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        with open(file_path, 'r', encoding='utf-8') as f:\n",
+    "            data = json.load(f)\n",
+    "    except (FileNotFoundError, json.JSONDecodeError) as e:\n",
+    "        print(f\"Error loading file: {e}\")\n",
+    "        return None, None\n",
+    "\n",
+    "    # --- FIX: Parse the nested JSON to extract numeric accuracy scores ---\n",
+    "    # Create a flat list of dictionaries instead of a list of nested objects\n",
+    "    parsed_data = []\n",
+    "    for record in data:\n",
+    "        parsed_data.append({\n",
+    "            \"id\": record.get(\"id\"),\n",
+    "            \"version\": record.get(\"version\"),\n",
+    "            \"completeness\": record.get(\"completeness\", {}).get(\"accuracy\", 0),\n",
+    "            \"conciseness\": record.get(\"conciseness\", {}).get(\"accuracy\", 0),\n",
+    "            \"attribution\": record.get(\"attribution\", {}).get(\"accuracy\", 0)\n",
+    "        })\n",
+    "\n",
+    "    # Create DataFrame from the *parsed* data\n",
+    "    df = pd.DataFrame(parsed_data)\n",
+    "    # --------------------------------------------------------------------\n",
+    "    \n",
+    "    all_ids = set(df['id'].unique())\n",
+    "    rejected_ids = set()\n",
+    "\n",
+    "    # --- Pivot data for easier comparison across versions ---\n",
+    "    # This part now works correctly because the columns are numeric\n",
+    "    pivot_df = df.pivot_table(\n",
+    "        index='id',\n",
+    "        columns='version',\n",
+    "        values=['completeness', 'conciseness', 'attribution']\n",
+    "    )\n",
+    "    pivot_df.columns = ['_'.join(map(str, col)).strip() for col in pivot_df.columns.values]\n",
+    "    \n",
+    "    # --- Filter 1: Low Attribution ---\n",
+    "    low_attribution_mask = (pivot_df['attribution_easy'] < attribution_threshold) | \\\n",
+    "                           (pivot_df['attribution_intermediate'] < attribution_threshold) | \\\n",
+    "                           (pivot_df['attribution_hard'] < attribution_threshold)\n",
+    "    rejected_attribution_ids = pivot_df[low_attribution_mask].index\n",
+    "    rejected_ids.update(rejected_attribution_ids)\n",
+    "    print(f\"Rejected {len(rejected_attribution_ids)} items due to low attribution.\")\n",
+    "\n",
+    "    # --- Filter 2: Incorrect Completeness Trend ---\n",
+    "    if completeness_trend_check:\n",
+    "        bad_trend_mask = pivot_df['completeness_easy'] > pivot_df['completeness_hard']\n",
+    "        rejected_trend_ids = pivot_df[bad_trend_mask].index\n",
+    "        newly_rejected_count = len(rejected_trend_ids.difference(rejected_ids))\n",
+    "        rejected_ids.update(rejected_trend_ids)\n",
+    "        print(f\"Rejected {newly_rejected_count} additional items due to incorrect completeness trend.\")\n",
+    "\n",
+    "    # --- Separate the data ---\n",
+    "    clean_ids = all_ids - rejected_ids\n",
+    "    \n",
+    "    # We need to filter the original 'data' list, not the parsed one, to keep the full structure\n",
+    "    original_df = pd.DataFrame(data)\n",
+    "    clean_data = original_df[original_df['id'].isin(clean_ids)].to_dict('records')\n",
+    "    rejected_data = original_df[original_df['id'].isin(rejected_ids)].to_dict('records')\n",
+    "    \n",
+    "    print(\"\\n--- Filtering Summary ---\")\n",
+    "    print(f\"Total unique items analyzed: {len(all_ids)}\")\n",
+    "    print(f\"Items kept (High Quality): {len(clean_ids)}\")\n",
+    "    print(f\"Items rejected (Low Quality): {len(rejected_ids)}\")\n",
+    "    \n",
+    "    return clean_data, rejected_data\n",
+    "\n",
+    "def save_json(data, file_path):\n",
+    "    \"\"\"Saves data to a JSON file.\"\"\"\n",
+    "    with open(file_path, 'w', encoding='utf-8') as f:\n",
+    "        json.dump(data, f, indent=4, ensure_ascii=False)\n",
+    "    print(f\"Saved data to '{file_path}'\")\n",
+    "\n",
+    "\n",
+    "# --- Main Execution ---\n",
+    "# Replace with your file paths and desired thresholds\n",
+    "RESULTS_FILE = '/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B.json' # Make sure this points to your file\n",
+    "# CLEAN_FILE_PATH = '/home/mshahidul/readctrl/results/dataset_quality_check/high_quality_dataset.json'\n",
+    "# REJECTED_FILE_PATH = '/home/mshahidul/readctrl/results/dataset_quality_check/rejected_dataset.json'\n",
+    "ATTRIBUTION_THRESHOLD = 80.0\n",
+    "\n",
+    "clean_dataset, rejected_dataset = filter_low_quality_data(\n",
+    "    RESULTS_FILE,\n",
+    "    attribution_threshold=ATTRIBUTION_THRESHOLD\n",
+    ")\n",
+    "\n",
+    "if clean_dataset is not None:\n",
+    "    save_json(clean_dataset, '/home/mshahidul/readctrl/results/dataset_quality_check/subclaim_verifier_results_100_qwen3-32B_clean.json')\n",
+    "    save_json(rejected_dataset, '/home/mshahidul/readctrl/results/dataset_quality_check/rejected_dataset.json')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "unsloth",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

code/finetune-inference/subclaim_support/readctrl_model.code-workspace

@@ -0,0 +1,13 @@
+{
+    "folders": [
+        {
+            "path": "../../.."
+        },
+        {
+            "path": "../../../../LLM_guard/CKA-Agent"
+        },
+        {
+            "path": "../../../../readctrl_model"
+        }
+    ]
+}

code/finetune-inference/subclaim_support_extraction/inference_extract_subclaims_gpt5.py

@@ -0,0 +1,206 @@
+import argparse
+import json
+import os
+import time
+from pathlib import Path
+from typing import List
+
+import tqdm
+from openai import OpenAI
+
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    prompt = f"""
+You are an expert medical annotator. Your task is to extract granular, factual subclaims from medical text.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Instructions:
+1. Read the provided medical text.
+2. Break it into clear, objective, atomic subclaims.
+3. Each subclaim must come directly from the text. Do not infer or add information.
+4. Keep subclaims short, non-overlapping, and de-duplicated.
+5. Preserve numbers, units, and dates exactly as written.
+6. If the text is empty, return an empty JSON list.
+7. Return ONLY a valid JSON list of strings (no extra text).
+
+Medical Text:
+{medical_text}
+
+Return your output in JSON list format:
+[
+  "subclaim 1",
+  "subclaim 2"
+]
+"""
+    return prompt
+
+
+def _load_openai_client() -> OpenAI:
+    api_file = "/home/mshahidul/api_new.json"
+    with open(api_file, "r") as f:
+        api_keys = json.load(f)
+    return OpenAI(api_key=api_keys["openai"])
+
+
+def _parse_json_list(text: str) -> List[str]:
+    cleaned = text.replace("```json", "").replace("```", "").strip()
+    start_idx = cleaned.find("[")
+    end_idx = cleaned.rfind("]") + 1
+    if start_idx == -1 or end_idx <= start_idx:
+        raise ValueError("No JSON list found")
+    parsed = json.loads(cleaned[start_idx:end_idx])
+    if not isinstance(parsed, list):
+        raise ValueError("Parsed JSON is not a list")
+    return parsed
+
+
+def infer_subclaims(
+    medical_text: str,
+    client: OpenAI,
+    model: str = "gpt-5-mini",
+    retries: int = 1,
+) -> List[str]:
+    if not medical_text or medical_text.strip() == "":
+        return []
+
+    prompt = extraction_prompt(medical_text)
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": "Return only a valid JSON list of strings."},
+                {"role": "user", "content": prompt},
+            ],
+        )
+        output_text = response.choices[0].message.content.strip()
+        return _parse_json_list(output_text)
+    except Exception as e:
+        if retries > 0:
+            time.sleep(1.5)
+            return infer_subclaims(
+                medical_text,
+                client,
+                model=model,
+                retries=retries - 1,
+            )
+        return [f"ERROR: {str(e)}"]
+
+
+# -----------------------------
+#  MAIN EXECUTION
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--input_file",
+        type=str,
+        default="/home/mshahidul/readctrl/data/annotators_validate_data_(20_80)/combine/verified_combined_0-80.json",
+    )
+    parser.add_argument(
+        "--save_folder",
+        type=str,
+        default="/home/mshahidul/readctrl/data/extracting_subclaim",
+    )
+    parser.add_argument("--model", type=str, default="gpt-5-mini")
+    args = parser.parse_args()
+
+    input_file = args.input_file
+    save_folder = args.save_folder
+    file_name = os.path.basename(input_file).split(".json")[0]
+    output_file = os.path.join(save_folder, f"extracted_subclaims_{file_name}.json")
+
+    Path(save_folder).mkdir(parents=True, exist_ok=True)
+    client = _load_openai_client()
+
+    with open(input_file, "r") as f:
+        data = json.load(f)
+
+    result = []
+    if os.path.exists(output_file):
+        with open(output_file, "r") as f:
+            result = json.load(f)
+
+    def _item_key(obj: dict) -> str:
+        if obj.get("index") is not None:
+            return str(obj.get("index"))
+        if obj.get("id") is not None:
+            return str(obj.get("id"))
+        if obj.get("doc_id") is not None and obj.get("label") is not None:
+            return f"{obj.get('doc_id')}_{obj.get('label')}"
+        return str(obj.get("doc_id") or obj.get("label") or "")
+
+    processed_data = {_item_key(item): item for item in result}
+
+    for item in tqdm.tqdm(data):
+        item_id = _item_key(item)
+        existing_entry = processed_data.get(item_id)
+
+        # 1. Process Fulltext
+        if not existing_entry or not isinstance(existing_entry.get("fulltext_subclaims"), list):
+            f_sub = infer_subclaims(
+                item.get("fulltext", ""),
+                client,
+                model=args.model,
+                retries=2,
+            )
+        else:
+            f_sub = existing_entry["fulltext_subclaims"]
+
+        # 2. Process Summary
+        if not existing_entry or not isinstance(existing_entry.get("summary_subclaims"), list):
+            s_sub = infer_subclaims(
+                item.get("summary", ""),
+                client,
+                model=args.model,
+                retries=1,
+            )
+        else:
+            s_sub = existing_entry["summary_subclaims"]
+
+        # 3. Process Generated Texts (diff_label_texts)
+        diff_label_texts = item.get("diff_label_texts", "")
+        if isinstance(diff_label_texts, dict):
+            diff_label_subclaims = existing_entry.get("diff_label_subclaims", {}) if existing_entry else {}
+            for label, text in diff_label_texts.items():
+                if label not in diff_label_subclaims or not isinstance(diff_label_subclaims[label], list):
+                    diff_label_subclaims[label] = infer_subclaims(
+                        text,
+                        client,
+                        model=args.model,
+                        retries=1,
+                    )
+        else:
+            if not existing_entry or not isinstance(existing_entry.get("diff_label_subclaims"), list):
+                diff_label_subclaims = infer_subclaims(
+                    diff_label_texts,
+                    client,
+                    model=args.model,
+                    retries=1,
+                )
+            else:
+                diff_label_subclaims = existing_entry["diff_label_subclaims"]
+
+        # 4. Save
+        new_entry = {
+            "doc_id": item.get("doc_id"),
+            "label": item.get("label"),
+            "fulltext": item.get("fulltext", ""),
+            "fulltext_subclaims": f_sub,
+            "summary": item.get("summary", ""),
+            "summary_subclaims": s_sub,
+            "diff_label_texts": diff_label_texts,
+            "diff_label_subclaims": diff_label_subclaims,
+        }
+        processed_data[item_id] = new_entry
+
+        if len(processed_data) % 10 == 0:
+            with open(output_file, "w") as f:
+                json.dump(list(processed_data.values()), f, indent=4, ensure_ascii=False)
+
+    with open(output_file, "w") as f:
+        json.dump(list(processed_data.values()), f, indent=4, ensure_ascii=False)
+
+    print(f"Extraction completed. File saved at: {output_file}")

code/finetune-inference/subclaim_support_extraction/inference_extract_subclaims_v4.py

@@ -0,0 +1,180 @@
+import os
+# Set GPU environment variables
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "2"
+import torch
+from unsloth import FastLanguageModel
+import json
+import tqdm
+import argparse
+
+
+# -----------------------------
+#  MODEL CACHE
+# -----------------------------
+_model_cache = {"model": None, "tokenizer": None}
+
+def load_finetuned_model(model_path: str):
+    if _model_cache["model"] is not None:
+        return _model_cache["model"], _model_cache["tokenizer"]
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_path,
+        max_seq_length=8192,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        full_finetuning=False,
+    )
+    _model_cache["model"], _model_cache["tokenizer"] = model, tokenizer
+    return model, tokenizer
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    prompt = f"""
+You are an expert medical annotator. Your task is to extract granular, factual subclaims from medical text.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Instructions:
+1. Read the provided medical text.
+2. Break it into clear, objective, atomic subclaims.
+3. Each subclaim must come directly from the text.
+4. Return ONLY a valid JSON list of strings.
+
+Medical Text:
+{medical_text}
+
+Return your output in JSON list format:
+[
+  "subclaim 1",
+  "subclaim 2"
+]
+"""
+    return prompt
+# -----------------------------
+#  INFERENCE FUNCTION WITH AUTO-RETRY
+# -----------------------------
+def infer_subclaims(medical_text: str, model, tokenizer, temperature: float = 0.2, max_tokens: int = 2048, retries: int = 1) -> list:
+    if not medical_text or medical_text.strip() == "":
+        return []
+
+    prompt = extraction_prompt(medical_text)
+    messages = [{"role": "user", "content": prompt}]
+    chat_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer(chat_text, return_tensors="pt").to("cuda")
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs, 
+            max_new_tokens=max_tokens, 
+            temperature=temperature, 
+            do_sample=False
+        )
+
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
+    
+    # Remove reasoning if model is a "Thinker" model
+    if "</think>" in output_text:
+        output_text = output_text.split("</think>")[-1].strip()
+
+    # JSON Parsing Logic
+    try:
+        start_idx = output_text.find('[')
+        end_idx = output_text.rfind(']') + 1
+        
+        # Check if we have a complete bracketed pair
+        if start_idx != -1 and end_idx > start_idx:
+            content = output_text[start_idx:end_idx]
+            parsed = json.loads(content)
+            if isinstance(parsed, list):
+                return parsed
+        
+        # If we are here, it means parsing failed or brackets were incomplete (truncation)
+        raise ValueError("Incomplete JSON list")
+
+    except (json.JSONDecodeError, ValueError):
+        # If truncation happened and we have retries left, double the tokens
+        if retries > 0:
+            new_max = max_tokens + 2048 # Increment by 2k tokens
+            print(f"\n[Warning] Truncation detected. Retrying with {new_max} tokens...")
+            return infer_subclaims(medical_text, model, tokenizer, temperature, max_tokens=new_max, retries=retries-1)
+        
+        # Final fallback: return the raw text wrapped in a list so the pipeline doesn't crash
+        return [output_text]
+
+# -----------------------------
+#  MAIN EXECUTION
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, required=True)
+    args = parser.parse_args()
+    
+    INPUT_FILE = args.input_file
+    file_name = os.path.basename(INPUT_FILE).split(".json")[0]
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    MODEL_PATH = "/home/mshahidul/readctrl_model/qwen3-32B_subclaims-extraction-8b_ctx"
+
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"extracted_subclaims_{file_name}.json")
+
+    model, tokenizer = load_finetuned_model(MODEL_PATH)
+
+    with open(INPUT_FILE, "r") as f:
+        data = json.load(f)
+
+    result = []
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r") as f:
+            result = json.load(f)
+
+    processed_data = {str(item.get("index") or item.get("id")): item for item in result}
+
+    for item in tqdm.tqdm(data):
+        item_id = str(item.get("index") if item.get("index") is not None else item.get("id"))
+        existing_entry = processed_data.get(item_id)
+
+        # 1. Process Fulltext (The longest field, high initial token count)
+        if not existing_entry or not isinstance(existing_entry.get("fulltext_subclaims"), list):
+            f_sub = infer_subclaims(item.get("fulltext", ""), model, tokenizer, max_tokens=3072, retries=2)
+        else:
+            f_sub = existing_entry["fulltext_subclaims"]
+
+        # 2. Process Summary
+        if not existing_entry or not isinstance(existing_entry.get("summary_subclaims"), list):
+            s_sub = infer_subclaims(item.get("summary", ""), model, tokenizer, max_tokens=2048, retries=1)
+        else:
+            s_sub = existing_entry["summary_subclaims"]
+
+        # 3. Process All Generated Texts (diff_label_texts)
+        diff_label_texts = item.get("diff_label_texts", {})
+        diff_label_subclaims = existing_entry.get("diff_label_subclaims", {}) if existing_entry else {}
+
+        for label, text in diff_label_texts.items():
+            if label not in diff_label_subclaims or not isinstance(diff_label_subclaims[label], list):
+                # Generated texts are shorter, but we still allow 1 retry
+                diff_label_subclaims[label] = infer_subclaims(text, model, tokenizer, max_tokens=1536, retries=1)
+
+        # 4. Save
+        new_entry = {
+            "index": item.get("index"),
+            "id": item.get("id"),
+            "fulltext": item.get("fulltext", ""),
+            "fulltext_subclaims": f_sub,
+            "summary": item.get("summary", ""),
+            "summary_subclaims": s_sub,
+            "diff_label_texts": diff_label_texts,
+            "diff_label_subclaims": diff_label_subclaims,
+            "readability_score": item.get("readability_score", None)
+        }
+        processed_data[item_id] = new_entry
+
+        if len(processed_data) % 10 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(list(processed_data.values()), f, indent=4, ensure_ascii=False)
+
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(list(processed_data.values()), f, indent=4, ensure_ascii=False)
+
+    print(f"Extraction completed. File saved at: {OUTPUT_FILE}")

code/finetune-inference/subclaim_support_extraction/inference_extract_subclaims_vllm.py

@@ -0,0 +1,163 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  API CONFIGURATION
+# -----------------------------
+LOCAL_API_URL = "http://172.16.34.29:8004/v1"
+LOCAL_MODEL_NAME = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-extraction-8b_ctx_fp16"
+
+client = OpenAI(
+    base_url=LOCAL_API_URL,
+    api_key="EMPTY"
+)
+
+# -----------------------------
+#  SUBCLAIM EXTRACTION PROMPT
+# -----------------------------
+def extraction_prompt(medical_text: str) -> str:
+    return f"""
+You are an expert medical annotator.
+
+Your task is to extract granular, factual subclaims from the provided medical text.
+A subclaim is the smallest standalone factual unit that can be independently verified.
+
+Instructions:
+1. Read the medical text carefully.
+2. Extract factual statements explicitly stated in the text.
+3. Each subclaim must:
+   - Contain exactly ONE factual assertion
+   - Come directly from the text (no inference or interpretation)
+   - Preserve original wording as much as possible
+   - Include any negation, uncertainty, or qualifier (e.g., "may", "not", "suggests")
+4. Do NOT:
+   - Combine multiple facts into one subclaim
+   - Add new information
+   - Rephrase or normalize terminology
+   - Include opinions or recommendations
+5. Return ONLY a valid JSON array of strings.
+6. Use double quotes and valid JSON formatting only (no markdown, no commentary).
+
+Medical Text:
+{medical_text}
+
+Return format:
+[
+  "subclaim 1",
+  "subclaim 2"
+]
+""".strip()
+
+
+# -----------------------------
+#  INFERENCE FUNCTION (vLLM API)
+# -----------------------------
+def infer_subclaims_api(medical_text: str, temperature: float = 0.2, max_tokens: int = 2048, retries: int = 1) -> list:
+    if not medical_text or not medical_text.strip():
+        return []
+
+    prompt = extraction_prompt(medical_text)
+    
+    try:
+        response = client.chat.completions.create(
+            model=LOCAL_MODEL_NAME,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+
+        output_text = response.choices[0].message.content.strip()
+        
+        if "</think>" in output_text:
+            output_text = output_text.split("</think>")[-1].strip()
+
+        start_idx = output_text.find('[')
+        end_idx = output_text.rfind(']') + 1
+        
+        if start_idx != -1 and end_idx > start_idx:
+            content = output_text[start_idx:end_idx]
+            parsed = json.loads(content)
+            if isinstance(parsed, list):
+                return parsed
+        
+        raise ValueError("Incomplete JSON list")
+
+    except (json.JSONDecodeError, ValueError, Exception) as e:
+        if retries > 0:
+            new_max = max_tokens + 2048 
+            print(f"\n[Warning] API error/truncation: {e}. Retrying with {new_max} tokens...")
+            return infer_subclaims_api(medical_text, temperature, max_tokens=new_max, retries=retries-1)
+        
+        return [output_text] if 'output_text' in locals() else []
+
+# -----------------------------
+#  MAIN EXECUTION
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, required=True)
+    parser.add_argument("--start", type=int, default=0, help="Start index in the dataset")
+    parser.add_argument("--end", type=int, default=None, help="End index (exclusive) in the dataset")
+    args = parser.parse_args()
+    
+    INPUT_FILE = args.input_file
+    file_name = os.path.basename(INPUT_FILE).split(".json")[0]
+    SAVE_FOLDER = "/home/mshahidul/readctrl/data/extracting_subclaim"
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+    
+    # Range-specific output naming helps if you want to run parallel jobs
+    range_suffix = f"_{args.start}_{args.end if args.end is not None else 'end'}"
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"extracted_subclaims_{file_name}{range_suffix}.json")
+
+    with open(INPUT_FILE, "r") as f:
+        full_data = json.load(f)
+    
+    if args.end is None:
+        args.end = len(full_data)
+
+    # Slice the data based on user input
+    data_subset = full_data[args.start:args.end]
+    print(f"Processing range [{args.start} : {args.end if args.end else len(full_data)}]. Total: {len(data_subset)} items.")
+
+    # Load existing progress if available
+    processed_data = {}
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r") as f:
+            existing_list = json.load(f)
+            processed_data = {str(item.get("id")): item for item in existing_list}
+
+    for item in tqdm.tqdm(data_subset):
+        item_id = str(item.get("id"))
+        
+        # Check if this item in the subset was already processed
+        if item_id in processed_data:
+            continue
+        
+        # 1. Process Fulltext
+        f_sub = infer_subclaims_api(item.get("fulltext", ""), max_tokens=3072, retries=2)
+
+        # 2. Process Summary
+        s_sub = infer_subclaims_api(item.get("summary", ""), max_tokens=2048, retries=1)
+
+        # 3. Save Entry
+        processed_data[item_id] = {
+            "id": item_id,
+            "fulltext": item.get("fulltext", ""),
+            "fulltext_subclaims": f_sub,
+            "summary": item.get("summary", ""),
+            "summary_subclaims": s_sub
+        }
+
+        # Periodic checkpoint
+        if len(processed_data) % 20 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(list(processed_data.values()), f, indent=4, ensure_ascii=False)
+
+    # Final Save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(list(processed_data.values()), f, indent=4, ensure_ascii=False)
+
+    print(f"Range extraction completed. File saved at: {OUTPUT_FILE}")

code/finetune-inference/subclaim_support_extraction/old/subclaim_support_cal.py

@@ -0,0 +1,248 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-support-check-4b_ctx-bf16"
+API_URL = "http://localhost:8015/v1" 
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  VERIFICATION PROMPT
+# -----------------------------
+def inference_prompt(text, subclaim):
+    return f"""
+You are a medical evidence evaluator.
+
+Determine the relationship between the following medical text and the subclaim.
+
+Label definitions:
+- supported: the text directly provides evidence for the subclaim
+- refuted: the text contradicts the subclaim
+- not_supported: the text is related to the subclaim but does not provide evidence
+
+
+Medical Text:
+{text}
+
+Subclaim:
+{subclaim}
+
+Respond only with one label: supported, refuted, or not_supported.
+Give output without extra explanation.
+"""
+
+# -----------------------------
+#  VERIFICATION LOGIC
+# -----------------------------
+def check_support(text: str, subclaim: str) -> str:
+    """
+    Returns: 'supported', 'refuted', or 'not_supported'
+    """
+    if not text or not subclaim:
+        return "not_supported"
+
+    prompt = inference_prompt(text, subclaim)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_PATH,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=20, 
+            temperature=0.0,
+        )
+        res = response.choices[0].message.content.strip().lower()
+        
+        if "not_supported" in res:
+            return "not_supported"
+        elif "supported" in res:
+            return "supported"
+        elif "refuted" in res:
+            return "refuted"
+        else:
+            return "not_supported"
+
+    except Exception as e:
+        print(f"API error: {e}")
+        return "not_supported"
+
+def calculate_metric(subclaims_list: list, reference_text: str, metric_name: str):
+    if not subclaims_list:
+        return {"score": 0.0, "details": []}
+    
+    results = []
+    supported_count = 0
+
+    for subclaim in subclaims_list:
+        label = check_support(reference_text, subclaim)
+        is_supported = (label == "supported")
+        
+        if is_supported:
+            supported_count += 1
+            
+        results.append({
+            "subclaim": subclaim,
+            "label": label
+        })
+
+    score = supported_count / len(subclaims_list) if len(subclaims_list) > 0 else 0.0
+    
+    return {
+        "score": score,
+        "details": results
+    }
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_full_data.json",
+                        help="Path to input JSON with subclaims")
+    
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/concise_complete_attr_cal_v2",
+                        help="Folder to save results")
+
+    # Range arguments
+    parser.add_argument("--start_index", type=int, default=0, help="Start index")
+    parser.add_argument("--end_index", type=int, default=-1, help="End index (exclusive). -1 for all.")
+
+    args = parser.parse_args()
+
+    INPUT_FILE = args.input_file
+    SAVE_FOLDER = args.save_folder
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    # -----------------------------
+    # Load Data
+    # -----------------------------
+    print(f"Loading data from {INPUT_FILE}...")
+    with open(INPUT_FILE, "r") as f:
+        all_data = json.load(f)
+
+    # -----------------------------
+    # Slice Data based on Range
+    # -----------------------------
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    
+    # Ensure end doesn't exceed total length
+    if end > total_len:
+        end = total_len
+
+    data_slice = all_data[start:end]
+
+    print(f"Total dataset size: {total_len}")
+    print(f"Processing range: {start} to {end}")
+    print(f"Items in this batch: {len(data_slice)}")
+
+    # -----------------------------
+    # Output Filename (includes range)
+    # -----------------------------
+    # Filename format: evaluated_metrics_0_100.json
+    OUTPUT_FILE = os.path.join(
+        SAVE_FOLDER, 
+        f"evaluated_metrics_{start}_{end}.json"
+    )
+
+    # -----------------------------
+    # Resume Logic
+    # -----------------------------
+    processed_results = []
+    if os.path.exists(OUTPUT_FILE):
+        print(f"Found existing output file: {OUTPUT_FILE}. Resuming...")
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                processed_results = json.load(f)
+        except:
+            processed_results = []
+    
+    processed_ids = {item['id'] for item in processed_results}
+    
+    # Filter only the sliced data
+    to_process = [item for item in data_slice if item['id'] not in processed_ids]
+
+    print(f"Already processed in this file: {len(processed_ids)}")
+    print(f"Remaining to process: {len(to_process)}")
+
+    # -----------------------------
+    # Processing Loop
+    # -----------------------------
+    for item in tqdm.tqdm(to_process):
+        
+        # 1. Prepare Texts
+        easy_text = item.get("easy_text", "")
+        inter_text = item.get("intermediate_text", "")
+        hard_text = item.get("hard_text", "")
+        fulltext = item.get("fulltext", "")
+        summary = item.get("summary", "")
+
+        # 2. Prepare Subclaim Lists
+        def ensure_list(x): return x if isinstance(x, list) else []
+        
+        easy_subs = ensure_list(item.get("easy_subclaims", []))
+        inter_subs = ensure_list(item.get("intermediate_subclaims", []))
+        hard_subs = ensure_list(item.get("hard_subclaims", []))
+        full_subs = ensure_list(item.get("fulltext_subclaims", [])) 
+        summary_subs = ensure_list(item.get("summary_subclaims", []))
+
+        # ---------------------------------------------------------
+        # METRICS CALCULATION
+        # ---------------------------------------------------------
+        
+        # Attribution: Generated Subclaims -> Full Text
+        attr_easy = calculate_metric(easy_subs, fulltext, "attribution")
+        attr_inter = calculate_metric(inter_subs, fulltext, "attribution")
+        attr_hard = calculate_metric(hard_subs, fulltext, "attribution")
+
+        # Conciseness: Generated Subclaims -> Summary Text
+        conc_easy = calculate_metric(easy_subs, summary, "conciseness")
+        conc_inter = calculate_metric(inter_subs, summary, "conciseness")
+        conc_hard = calculate_metric(hard_subs, summary, "conciseness")
+
+        # Completeness: summary Subclaims -> Generated Text
+        comp_easy = calculate_metric(summary_subs, easy_text, "completeness")
+        comp_inter = calculate_metric(summary_subs, inter_text, "completeness")
+        comp_hard = calculate_metric(summary_subs, hard_text, "completeness")
+
+        # Construct Output
+        result_item = item.copy()
+        result_item["metrics"] = {
+            "easy": {
+                "attribution": attr_easy,
+                "conciseness": conc_easy,
+                "completeness": comp_easy
+            },
+            "intermediate": {
+                "attribution": attr_inter,
+                "conciseness": conc_inter,
+                "completeness": comp_inter
+            },
+            "hard": {
+                "attribution": attr_hard,
+                "conciseness": conc_hard,
+                "completeness": comp_hard
+            }
+        }
+        
+        processed_results.append(result_item)
+
+        # Save frequently
+        if len(processed_results) % 20 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(processed_results, f, indent=4, ensure_ascii=False)
+
+    # Final Save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(processed_results, f, indent=4, ensure_ascii=False)
+
+    print(f"Evaluation for range {start}:{end} complete. Saved to: {OUTPUT_FILE}")

code/finetune-inference/subclaim_support_extraction/old/subclaim_support_cal_tesing_v2.py

@@ -0,0 +1,203 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-support-check-8b_ctx-bf16"
+API_URL = "http://172.16.34.29:8004/v1" 
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  VERIFICATION PROMPT
+# -----------------------------
+def inference_prompt(text, subclaim):
+    return f"""You are a clinical evidence auditor. Your evaluation must be based STRICTLY and ONLY on the provided medical text. 
+
+### MANDATORY GROUNDING RULES:
+1. NO OUTSIDE KNOWLEDGE: Do not use your internal medical knowledge. Even if a subclaim is "common sense" in medicine, if it is not explicitly in the TEXT, it is 'not_supported'.
+2. NO LOGICAL LEAPS: Do not bridge gaps in logic. (e.g., If the text mentions "high blood sugar" but not the word "diabetes", you cannot support a claim of "diabetes").
+3. EXACT NUMERICAL MATCHING: Any doses (e.g., 500mg), frequencies (e.g., twice daily), or durations (e.g., 10 days) mentioned in the subclaim must match the text perfectly. If they are missing or different in the text, label as 'not_supported'.
+4. DEFAULT TO NOT SUPPORTED: If the text is vague, ambiguous, or only suggests a possibility, you MUST choose 'not_supported'. 
+5. CLOSED-WORLD REALITY: Treat the TEXT as the only information that exists in the world.
+
+### Medical Text:
+{text}
+
+### Subclaim:
+{subclaim}
+
+Output exactly one word ('supported' or 'not_supported') based on the strict rules above:"""
+
+# -----------------------------
+#  VERIFICATION LOGIC
+# -----------------------------
+def check_support(text: str, subclaim: str, error_log=None) -> str:
+    """
+    Returns: 'supported', 'refuted', or 'not_supported'
+    Tracks errors in error_log if provided.
+    """
+    if not text or not subclaim:
+        return "not_supported"
+
+    prompt = inference_prompt(text, subclaim)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_PATH,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=512, 
+            temperature=0.1,
+        )
+        res = response.choices[0].message.content
+        if "</think>" in res:
+            res = res.split("</think>")[1].strip().lower()
+        else:
+            res = response.choices[0].message.content.strip().lower()
+
+        if "not_supported" in res:
+            return "not_supported"
+        elif "supported" in res:
+            return "supported"
+        elif "refuted" in res:
+            return "refuted"
+        else:
+            return "not_supported"
+
+    except Exception as e:
+        # --- ERROR TRACKING ---
+        if error_log is not None:
+            error_details = {
+                "subclaim": subclaim,
+                "error_msg": str(e),
+                "type": "API_ERROR"
+            }
+            error_log.append(error_details)
+        # ----------------------
+        
+        # Optional: Print to console so you see it happening live
+        # print(f"\n[!] Error on ID {item_id}: {e}")
+        return "not_supported"
+
+
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/model_validity_check/subclaims_support_validity_check_gt_gpt5(1-5).json",
+                        help="Path to input JSON with subclaims")
+    
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/concise_complete_attr_testing",
+                        help="Folder to save results")
+
+    # Range arguments
+    parser.add_argument("--start_index", type=int, default=0, help="Start index")
+    parser.add_argument("--end_index", type=int, default=-1, help="End index (exclusive). -1 for all.")
+
+    args = parser.parse_args()
+
+    INPUT_FILE = args.input_file
+    SAVE_FOLDER = args.save_folder
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    # -----------------------------
+    # Load Data
+    # -----------------------------
+    print(f"Loading data from {INPUT_FILE}...")
+    with open(INPUT_FILE, "r") as f:
+        all_data = json.load(f)
+
+    # -----------------------------
+    # Slice Data based on Range
+    # -----------------------------
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    
+    if end > total_len:
+        end = total_len
+
+    data_slice = all_data[start:end]
+
+    print(f"Total dataset size: {total_len}")
+    print(f"Processing range: {start} to {end}")
+    print(f"Items in this batch: {len(data_slice)}")
+
+    # -----------------------------
+    # Output Files
+    # -----------------------------
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"evaluated_metrics_{start}_{end}_qwen3_32B_v2.json")
+   
+
+    # -----------------------------
+    # Resume Logic
+    # -----------------------------
+    processed_results = []
+    if os.path.exists(OUTPUT_FILE):
+        print(f"Found existing output file: {OUTPUT_FILE}. Resuming...")
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                processed_results = json.load(f)
+        except:
+            processed_results = []
+    
+    processed_ids = {item['full_text'] for item in processed_results}
+    to_process = [item for item in data_slice if item['full_text'] not in processed_ids]
+
+    print(f"Already processed in this file: {len(processed_ids)}")
+    print(f"Remaining to process: {len(to_process)}")
+
+    # -----------------------------
+    # Initialize Error Tracker
+    # -----------------------------
+    global_error_log = []
+
+    # -----------------------------
+    # Processing Loop
+    # -----------------------------
+    # Added tqdm postfix to show error count in real-time
+    pbar = tqdm.tqdm(to_process)
+    
+    for item in pbar:
+        text=item.get('full_text', '')
+        subclaims=item.get('dat', [])['dat']
+        # import ipdb; ipdb.set_trace()
+        for subclaim in subclaims:
+            subclaim_text=subclaim.get('subclaim', '')
+            label_gt=subclaim.get('status', 'not_supported').strip().lower()
+            correctness=False
+            
+            label_gen=check_support(text, subclaim_text, error_log=global_error_log)
+            # import ipdb; ipdb.set_trace()
+            if "not_supported" == label_gen and "not_supported" == label_gt:
+                correctness=True
+            elif "supported" == label_gen and "supported" == label_gt:
+                correctness=True
+            else:
+                # print(f"Mismatch:\nGT: {label_gt}\nGEN: {label_gen}\nSubclaim: {subclaim}\nText: {text}\n---")
+                pass
+            result_entry={
+                "medical_text": text,
+                "subclaim": subclaim,
+                "label_gt": label_gt,
+                "label_gen": label_gen,
+                "correctness": correctness
+            }
+            processed_results.append(result_entry)
+            if len(processed_results) % 2 == 0:
+                # Save intermediate results
+                with open(OUTPUT_FILE, "w") as f:
+                    json.dump(processed_results, f, indent=2, ensure_ascii=False)
+
+
+with open(OUTPUT_FILE, "w") as f:
+    json.dump(processed_results, f, indent=2, ensure_ascii=False)

code/finetune-inference/subclaim_support_extraction/old/subclaim_support_cal_v2.py

@@ -0,0 +1,304 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-support-check-8b_ctx-bf16"
+API_URL = "http://localhost:8015/v1" 
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  VERIFICATION PROMPT
+# -----------------------------
+def inference_prompt(text, subclaim):
+    return f"""
+You are a precise, conservative medical evidence evaluator.
+
+Your task:
+Determine the relationship between the following MEDICAL TEXT and the SUBCLAIM.
+
+Use ONLY these labels (lowercase):
+- supported      → the TEXT clearly supports the SUBCLAIM. The information is
+                   explicitly stated or follows from a very direct and
+                   unambiguous medical inference (e.g., “fiebre de 39°C”
+                   supports “tenía fiebre”).
+- refuted        → the TEXT clearly contradicts the SUBCLAIM (e.g., the TEXT
+                   states the opposite, or provides mutually exclusive values:
+                   different drug, dose, duration, time point, diagnosis, etc.).
+- not_supported  → the TEXT is related to the SUBCLAIM but does NOT provide
+                   enough evidence to mark it as supported or refuted
+                   (e.g., missing or different dose, duration, timing,
+                   route, frequency, or diagnosis; or the claim simply
+                   is not mentioned).
+
+Important instructions:
+- Be STRICT and CONSERVATIVE:
+  - If exact numerical details (dose, time, duration, frequency, age, etc.)
+    in the SUBCLAIM are not explicitly stated or clearly implied in the TEXT,
+    choose not_supported.
+  - Do NOT assume or infer information beyond what is clearly supported by
+    the TEXT, even if it seems medically plausible.
+  - Use refuted ONLY when there is a clear contradiction between TEXT and
+    SUBCLAIM.
+- Ignore your external medical knowledge; base your decision ONLY on the TEXT.
+- The TEXT and SUBCLAIM may be in Spanish; evaluate them as written.
+
+Medical Text:
+{text}
+
+Subclaim:
+{subclaim}
+
+Respond with exactly ONE label:
+supported
+refuted
+not_supported
+"""
+
+# -----------------------------
+#  VERIFICATION LOGIC
+# -----------------------------
+def check_support(text: str, subclaim: str, item_id=None, error_log=None) -> str:
+    """
+    Returns: 'supported', 'refuted', or 'not_supported'
+    Tracks errors in error_log if provided.
+    """
+    if not text or not subclaim:
+        return "not_supported"
+
+    prompt = inference_prompt(text, subclaim)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_PATH,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=20, 
+            temperature=0.0,
+        )
+        res = response.choices[0].message.content.strip().lower()
+        
+        if "not_supported" in res:
+            return "not_supported"
+        elif "supported" in res:
+            return "supported"
+        elif "refuted" in res:
+            return "refuted"
+        else:
+            return "not_supported"
+
+    except Exception as e:
+        # --- ERROR TRACKING ---
+        if error_log is not None:
+            error_details = {
+                "id": item_id,
+                "subclaim": subclaim,
+                "error_msg": str(e),
+                "type": "API_ERROR"
+            }
+            error_log.append(error_details)
+        # ----------------------
+        
+        # Optional: Print to console so you see it happening live
+        print(f"\n[!] Error on ID {item_id}: {e}")
+        return "not_supported"
+
+def calculate_metric(subclaims_list: list, reference_text: str, metric_name: str, item_id=None, error_log=None):
+    if not subclaims_list:
+        return {"score": 0.0, "details": []}
+    
+    results = []
+    supported_count = 0
+
+    for subclaim in subclaims_list:
+        # Pass tracking info down to check_support
+        label = check_support(reference_text, subclaim, item_id=item_id, error_log=error_log)
+        
+        is_supported = (label == "supported")
+        
+        if is_supported:
+            supported_count += 1
+            
+        results.append({
+            "subclaim": subclaim,
+            "label": label
+        })
+
+    score = supported_count / len(subclaims_list) if len(subclaims_list) > 0 else 0.0
+    
+    return {
+        "score": score,
+        "details": results
+    }
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_full_data.json",
+                        help="Path to input JSON with subclaims")
+    
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/concise_complete_attr_cal_v3",
+                        help="Folder to save results")
+
+    # Range arguments
+    parser.add_argument("--start_index", type=int, default=0, help="Start index")
+    parser.add_argument("--end_index", type=int, default=-1, help="End index (exclusive). -1 for all.")
+
+    args = parser.parse_args()
+
+    INPUT_FILE = args.input_file
+    SAVE_FOLDER = args.save_folder
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    # -----------------------------
+    # Load Data
+    # -----------------------------
+    print(f"Loading data from {INPUT_FILE}...")
+    with open(INPUT_FILE, "r") as f:
+        all_data = json.load(f)
+
+    # -----------------------------
+    # Slice Data based on Range
+    # -----------------------------
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    
+    if end > total_len:
+        end = total_len
+
+    data_slice = all_data[start:end]
+
+    print(f"Total dataset size: {total_len}")
+    print(f"Processing range: {start} to {end}")
+    print(f"Items in this batch: {len(data_slice)}")
+
+    # -----------------------------
+    # Output Files
+    # -----------------------------
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"evaluated_metrics_{start}_{end}.json")
+    ERROR_LOG_FILE = os.path.join(SAVE_FOLDER, f"error_log_{start}_{end}.json")
+
+    # -----------------------------
+    # Resume Logic
+    # -----------------------------
+    processed_results = []
+    if os.path.exists(OUTPUT_FILE):
+        print(f"Found existing output file: {OUTPUT_FILE}. Resuming...")
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                processed_results = json.load(f)
+        except:
+            processed_results = []
+    
+    processed_ids = {item['id'] for item in processed_results}
+    to_process = [item for item in data_slice if item['id'] not in processed_ids]
+
+    print(f"Already processed in this file: {len(processed_ids)}")
+    print(f"Remaining to process: {len(to_process)}")
+
+    # -----------------------------
+    # Initialize Error Tracker
+    # -----------------------------
+    global_error_log = []
+
+    # -----------------------------
+    # Processing Loop
+    # -----------------------------
+    # Added tqdm postfix to show error count in real-time
+    pbar = tqdm.tqdm(to_process)
+    
+    for item in pbar:
+        current_id = item.get('id', 'unknown')
+        
+        # 1. Prepare Texts
+        easy_text = item.get("easy_text", "")
+        inter_text = item.get("intermediate_text", "")
+        hard_text = item.get("hard_text", "")
+        fulltext = item.get("fulltext", "")
+        summary = item.get("summary", "")
+
+        # 2. Prepare Subclaim Lists
+        def ensure_list(x): return x if isinstance(x, list) else []
+        
+        easy_subs = ensure_list(item.get("easy_subclaims", []))
+        inter_subs = ensure_list(item.get("intermediate_subclaims", []))
+        hard_subs = ensure_list(item.get("hard_subclaims", []))
+        full_subs = ensure_list(item.get("fulltext_subclaims", [])) 
+        summary_subs = ensure_list(item.get("summary_subclaims", []))
+
+        # ---------------------------------------------------------
+        # METRICS CALCULATION (Now passing id and error_log)
+        # ---------------------------------------------------------
+        
+        # Attribution: Generated Subclaims -> Full Text
+        attr_easy = calculate_metric(easy_subs, fulltext, "attribution", current_id, global_error_log)
+        attr_inter = calculate_metric(inter_subs, fulltext, "attribution", current_id, global_error_log)
+        attr_hard = calculate_metric(hard_subs, fulltext, "attribution", current_id, global_error_log)
+
+        # Conciseness: Generated Subclaims -> Summary Text
+        conc_easy = calculate_metric(easy_subs, summary, "conciseness", current_id, global_error_log)
+        conc_inter = calculate_metric(inter_subs, summary, "conciseness", current_id, global_error_log)
+        conc_hard = calculate_metric(hard_subs, summary, "conciseness", current_id, global_error_log)
+
+        # Completeness: summary Subclaims -> Generated Text
+        comp_easy = calculate_metric(summary_subs, easy_text, "completeness", current_id, global_error_log)
+        comp_inter = calculate_metric(summary_subs, inter_text, "completeness", current_id, global_error_log)
+        comp_hard = calculate_metric(summary_subs, hard_text, "completeness", current_id, global_error_log)
+
+        # Construct Output
+        result_item = item.copy()
+        result_item["metrics"] = {
+            "easy": {
+                "attribution": attr_easy,
+                "conciseness": conc_easy,
+                "completeness": comp_easy
+            },
+            "intermediate": {
+                "attribution": attr_inter,
+                "conciseness": conc_inter,
+                "completeness": comp_inter
+            },
+            "hard": {
+                "attribution": attr_hard,
+                "conciseness": conc_hard,
+                "completeness": comp_hard
+            }
+        }
+        
+        processed_results.append(result_item)
+
+        # Update progress bar with error count
+        if len(global_error_log) > 0:
+            pbar.set_postfix({"Errors": len(global_error_log)})
+
+        # Save frequently
+        if len(processed_results) % 10 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(processed_results, f, indent=4, ensure_ascii=False)
+
+    # Final Save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(processed_results, f, indent=4, ensure_ascii=False)
+
+    print(f"Evaluation for range {start}:{end} complete. Saved to: {OUTPUT_FILE}")
+
+    # -----------------------------
+    # Error Reporting
+    # -----------------------------
+    if global_error_log:
+        print(f"\n⚠️  WARNING: {len(global_error_log)} API errors occurred during processing.")
+        with open(ERROR_LOG_FILE, "w") as f:
+            json.dump(global_error_log, f, indent=4)
+        print(f"Error details saved to: {ERROR_LOG_FILE}")
+    else:
+        print("\n✅ Success: No API errors detected.")

code/finetune-inference/subclaim_support_extraction/old/subclaim_support_cal_v3.py

@@ -0,0 +1,256 @@
+import os
+import json
+import argparse
+import re
+from vllm import LLM, SamplingParams
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_PATH = "Qwen/Qwen3-30B-A3B-Thinking-2507"
+
+# -----------------------------
+#  PROMPT & CLEANING
+# -----------------------------
+def inference_prompt(text, subclaim):
+    return f"""
+You are a precise, conservative medical evidence evaluator.
+
+Your task:
+Determine the relationship between the following MEDICAL TEXT and the SUBCLAIM.
+
+Use ONLY these labels (lowercase):
+- supported      → the TEXT clearly supports the SUBCLAIM.
+- refuted        → the TEXT clearly contradicts the SUBCLAIM.
+- not_supported  → the TEXT is related to the SUBCLAIM but does NOT provide enough evidence.
+
+Important instructions:
+- Analyze the text carefully before deciding.
+- Be STRICT and CONSERVATIVE.
+- If exact numerical details differ or are missing, choose not_supported.
+- Respond with exactly ONE label at the end.
+
+Medical Text:
+{text}
+
+Subclaim:
+{subclaim}
+
+Respond with exactly ONE label:
+supported
+refuted
+not_supported
+"""
+
+def clean_response(text):
+    """
+    Removes <think> tags and extracts the final label.
+    """
+    if not text:
+        return "not_supported"
+    
+    # Remove thinking block
+    text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL)
+    text = text.strip().lower()
+    
+    # Extract the last valid label found
+    valid_labels = ["not_supported", "supported", "refuted"]
+    
+    # Check if the text ends with a valid label (ignoring punctuation)
+    for label in valid_labels:
+        if label in text:
+            return label
+            
+    return "not_supported"
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_full_data.json")
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/concise_complete_attr_cal_v4")
+    parser.add_argument("--start_index", type=int, default=0)
+    parser.add_argument("--end_index", type=int, default=-1)
+    
+    # vLLM Performance Arguments
+    parser.add_argument("--gpu_utilization", type=float, default=0.95)
+    parser.add_argument("--max_model_len", type=int, default=16384) # Adjusted for A100 80GB
+
+    args = parser.parse_args()
+
+    # 1. Setup Data
+    INPUT_FILE = args.input_file
+    SAVE_FOLDER = args.save_folder
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"evaluated_metrics_{args.start_index}_{args.end_index}.json")
+
+    print(f"Loading data from {INPUT_FILE}...")
+    with open(INPUT_FILE, "r") as f:
+        all_data = json.load(f)
+
+    # Slice Data
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    data_slice = all_data[start:end]
+    print(f"Processing range: {start} to {end} ({len(data_slice)} items)")
+
+    # -----------------------------
+    # PHASE 1: PREPARE PROMPTS
+    # -----------------------------
+    print("Building prompt list...")
+    
+    # We need to flatten the hierarchy to feed vLLM a single list of strings
+    # We will store metadata to reconstruct the structure later
+    prompts_list = []
+    request_metadata = [] # Syncs index-to-index with prompts_list
+
+    def add_request(item_id, text, subclaims, metric_type, level):
+        if not subclaims or not isinstance(subclaims, list):
+            return
+        for sub in subclaims:
+            p = inference_prompt(text, sub)
+            prompts_list.append(p)
+            request_metadata.append({
+                "id": item_id,
+                "metric_type": metric_type, # 'attribution', 'conciseness', 'completeness'
+                "level": level,             # 'easy', 'intermediate', 'hard'
+                "subclaim": sub
+            })
+
+    for item in data_slice:
+        itm_id = item.get('id')
+        fulltext = item.get("fulltext", "")
+        summary = item.get("summary", "")
+        
+        easy_txt = item.get("easy_text", "")
+        inter_txt = item.get("intermediate_text", "")
+        hard_txt = item.get("hard_text", "")
+
+        # A. ATTRIBUTION (Subclaims -> Fulltext)
+        add_request(itm_id, fulltext, item.get("easy_subclaims", []), "attribution", "easy")
+        add_request(itm_id, fulltext, item.get("intermediate_subclaims", []), "attribution", "intermediate")
+        add_request(itm_id, fulltext, item.get("hard_subclaims", []), "attribution", "hard")
+
+        # B. CONCISENESS (Subclaims -> Summary)
+        add_request(itm_id, summary, item.get("easy_subclaims", []), "conciseness", "easy")
+        add_request(itm_id, summary, item.get("intermediate_subclaims", []), "conciseness", "intermediate")
+        add_request(itm_id, summary, item.get("hard_subclaims", []), "conciseness", "hard")
+
+        # C. COMPLETENESS (Summary Subclaims -> Generated Text)
+        sum_subs = item.get("summary_subclaims", [])
+        add_request(itm_id, easy_txt, sum_subs, "completeness", "easy")
+        add_request(itm_id, inter_txt, sum_subs, "completeness", "intermediate")
+        add_request(itm_id, hard_txt, sum_subs, "completeness", "hard")
+
+    print(f"Total inference requests generated: {len(prompts_list)}")
+
+    if len(prompts_list) == 0:
+        print("No subclaims found to process.")
+        exit()
+
+    # -----------------------------
+    # PHASE 2: BATCH INFERENCE
+    # -----------------------------
+    print("Initializing vLLM Engine...")
+    llm = LLM(
+        model=MODEL_PATH,
+        trust_remote_code=True,
+        dtype="bfloat16",
+        gpu_memory_utilization=args.gpu_utilization,
+        max_model_len=args.max_model_len,
+        enforce_eager=True # Helps with Qwen MoE stability
+    )
+
+    # Allow max_tokens for "Thinking", but we only keep the label later
+    sampling_params = SamplingParams(temperature=0, max_tokens=1024)
+
+    print("Running Inference...")
+    outputs = llm.generate(prompts_list, sampling_params)
+
+    # -----------------------------
+    # PHASE 3: AGGREGATE RESULTS
+    # -----------------------------
+    print("Aggregating results...")
+
+    # Dictionary to reconstruct the data: results_map[id][metric][level] = list of results
+    results_map = {}
+
+    for i, output in enumerate(outputs):
+        meta = request_metadata[i]
+        generated_text = output.outputs[0].text
+        
+        # Clean the Qwen "Thinking" output
+        label = clean_response(generated_text)
+        
+        item_id = meta['id']
+        metric = meta['metric_type']
+        level = meta['level']
+        
+        if item_id not in results_map:
+            results_map[item_id] = {
+                "attribution": {"easy": [], "intermediate": [], "hard": []},
+                "conciseness": {"easy": [], "intermediate": [], "hard": []},
+                "completeness": {"easy": [], "intermediate": [], "hard": []},
+            }
+        
+        results_map[item_id][metric][level].append({
+            "subclaim": meta['subclaim'],
+            "label": label
+        })
+
+    # -----------------------------
+    # PHASE 4: CALCULATE SCORES & SAVE
+    # -----------------------------
+    final_output = []
+
+    for original_item in data_slice:
+        itm_id = original_item.get('id')
+        
+        # Create a clean copy of the item
+        new_item = original_item.copy()
+        
+        # Structure for metrics
+        metrics_struct = {
+            "easy": {}, "intermediate": {}, "hard": {}
+        }
+        
+        # If we processed this item (it had subclaims)
+        if itm_id in results_map:
+            raw_data = results_map[itm_id]
+            
+            # Iterate levels (easy, intermediate, hard)
+            for level in ["easy", "intermediate", "hard"]:
+                # Iterate metrics (attribution, conciseness, completeness)
+                for metric in ["attribution", "conciseness", "completeness"]:
+                    
+                    subclaim_results = raw_data[metric][level]
+                    total = len(subclaim_results)
+                    supported = sum(1 for x in subclaim_results if x['label'] == 'supported')
+                    score = (supported / total) if total > 0 else 0.0
+                    
+                    metrics_struct[level][metric] = {
+                        "score": score,
+                        "details": subclaim_results
+                    }
+        else:
+            # Handle empty items
+            empty_res = {"score": 0.0, "details": []}
+            for level in ["easy", "intermediate", "hard"]:
+                metrics_struct[level] = {
+                    "attribution": empty_res,
+                    "conciseness": empty_res,
+                    "completeness": empty_res
+                }
+
+        new_item["metrics"] = metrics_struct
+        final_output.append(new_item)
+
+    print(f"Saving {len(final_output)} items to {OUTPUT_FILE}...")
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(final_output, f, indent=4, ensure_ascii=False)
+
+    print("Done.")

code/finetune-inference/subclaim_support_extraction/old/subclaim_support_cal_v4.py

@@ -0,0 +1,309 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-support-check-8b_ctx_v2-bf16"
+API_URL = "http://172.16.34.29:8004/v1" 
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  VERIFICATION PROMPT
+# -----------------------------
+def inference_prompt(text, subclaim):
+    return f"""
+You are a precise, conservative medical evidence evaluator.
+
+Your task:
+Determine the relationship between the following MEDICAL TEXT and the SUBCLAIM.
+
+Use ONLY these labels (lowercase):
+- supported      → the TEXT clearly supports the SUBCLAIM. The information is
+                   explicitly stated or follows from a very direct and
+                   unambiguous medical inference (e.g., “fiebre de 39°C”
+                   supports “tenía fiebre”).
+- refuted        → the TEXT clearly contradicts the SUBCLAIM (e.g., the TEXT
+                   states the opposite, or provides mutually exclusive values:
+                   different drug, dose, duration, time point, diagnosis, etc.).
+- not_supported  → the TEXT is related to the SUBCLAIM but does NOT provide
+                   enough evidence to mark it as supported or refuted
+                   (e.g., missing or different dose, duration, timing,
+                   route, frequency, or diagnosis; or the claim simply
+                   is not mentioned).
+
+Important instructions:
+- Be STRICT and CONSERVATIVE:
+  - If exact numerical details (dose, time, duration, frequency, age, etc.)
+    in the SUBCLAIM are not explicitly stated or clearly implied in the TEXT,
+    choose not_supported.
+  - Do NOT assume or infer information beyond what is clearly supported by
+    the TEXT, even if it seems medically plausible.
+  - Use refuted ONLY when there is a clear contradiction between TEXT and
+    SUBCLAIM.
+- Ignore your external medical knowledge; base your decision ONLY on the TEXT.
+- The TEXT and SUBCLAIM may be in Spanish; evaluate them as written.
+- Do NOT add any explanation, justification, or extra text.
+
+Medical Text:
+{text}
+
+Subclaim:
+{subclaim}
+
+Respond with exactly ONE label:
+supported
+refuted
+not_supported
+"""
+
+# -----------------------------
+#  VERIFICATION LOGIC
+# -----------------------------
+def check_support(text: str, subclaim: str, item_id=None, error_log=None) -> str:
+    """
+    Returns: 'supported', 'refuted', or 'not_supported'
+    Tracks errors in error_log if provided.
+    """
+    if not text or not subclaim:
+        return "not_supported"
+
+    prompt = inference_prompt(text, subclaim)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_PATH,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=512, 
+            temperature=0.1,
+        )
+        res = response.choices[0].message.content
+        if "</think>" in res:
+            res = res.split("</think>")[1].strip().lower()
+        else:
+            res = response.choices[0].message.content.strip().lower()
+
+        if "not_supported" in res:
+            return "not_supported"
+        elif "supported" in res:
+            return "supported"
+        elif "refuted" in res:
+            return "refuted"
+        else:
+            return "not_supported"
+
+    except Exception as e:
+        # --- ERROR TRACKING ---
+        if error_log is not None:
+            error_details = {
+                "id": item_id,
+                "subclaim": subclaim,
+                "error_msg": str(e),
+                "type": "API_ERROR"
+            }
+            error_log.append(error_details)
+        # ----------------------
+        
+        # Optional: Print to console so you see it happening live
+        print(f"\n[!] Error on ID {item_id}: {e}")
+        return "not_supported"
+
+def calculate_metric(subclaims_list: list, reference_text: str, metric_name: str, item_id=None, error_log=None):
+    if not subclaims_list:
+        return {"score": 0.0, "details": []}
+    
+    results = []
+    supported_count = 0
+
+    for subclaim in subclaims_list:
+        # Pass tracking info down to check_support
+        label = check_support(reference_text, subclaim, item_id=item_id, error_log=error_log)
+        
+        is_supported = (label == "supported")
+        
+        if is_supported:
+            supported_count += 1
+            
+        results.append({
+            "subclaim": subclaim,
+            "label": label
+        })
+
+    score = supported_count / len(subclaims_list) if len(subclaims_list) > 0 else 0.0
+    
+    return {
+        "score": score,
+        "details": results
+    }
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_full_data.json",
+                        help="Path to input JSON with subclaims")
+    
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/concise_complete_attr_cal_v4",
+                        help="Folder to save results")
+
+    # Range arguments
+    parser.add_argument("--start_index", type=int, default=0, help="Start index")
+    parser.add_argument("--end_index", type=int, default=6, help="End index (exclusive). -1 for all.")
+
+    args = parser.parse_args()
+
+    INPUT_FILE = args.input_file
+    SAVE_FOLDER = args.save_folder
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    # -----------------------------
+    # Load Data
+    # -----------------------------
+    print(f"Loading data from {INPUT_FILE}...")
+    with open(INPUT_FILE, "r") as f:
+        all_data = json.load(f)
+
+    # -----------------------------
+    # Slice Data based on Range
+    # -----------------------------
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    
+    if end > total_len:
+        end = total_len
+
+    data_slice = all_data[start:end]
+
+    print(f"Total dataset size: {total_len}")
+    print(f"Processing range: {start} to {end}")
+    print(f"Items in this batch: {len(data_slice)}")
+
+    # -----------------------------
+    # Output Files
+    # -----------------------------
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"evaluated_metrics_{start}_{end}.json")
+    ERROR_LOG_FILE = os.path.join(SAVE_FOLDER, f"error_log_{start}_{end}.json")
+
+    # -----------------------------
+    # Resume Logic
+    # -----------------------------
+    processed_results = []
+    if os.path.exists(OUTPUT_FILE):
+        print(f"Found existing output file: {OUTPUT_FILE}. Resuming...")
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                processed_results = json.load(f)
+        except:
+            processed_results = []
+    
+    processed_ids = {item['id'] for item in processed_results}
+    to_process = [item for item in data_slice if item['id'] not in processed_ids]
+
+    print(f"Already processed in this file: {len(processed_ids)}")
+    print(f"Remaining to process: {len(to_process)}")
+
+    # -----------------------------
+    # Initialize Error Tracker
+    # -----------------------------
+    global_error_log = []
+
+    # -----------------------------
+    # Processing Loop
+    # -----------------------------
+    # Added tqdm postfix to show error count in real-time
+    pbar = tqdm.tqdm(to_process)
+    
+    for item in pbar:
+        current_id = item.get('id', 'unknown')
+        
+        # 1. Prepare Texts
+        easy_text = item.get("easy_text", "")
+        inter_text = item.get("intermediate_text", "")
+        hard_text = item.get("hard_text", "")
+        fulltext = item.get("fulltext", "")
+        summary = item.get("summary", "")
+
+        # 2. Prepare Subclaim Lists
+        def ensure_list(x): return x if isinstance(x, list) else []
+        
+        easy_subs = ensure_list(item.get("easy_subclaims", []))
+        inter_subs = ensure_list(item.get("intermediate_subclaims", []))
+        hard_subs = ensure_list(item.get("hard_subclaims", []))
+        full_subs = ensure_list(item.get("fulltext_subclaims", [])) 
+        summary_subs = ensure_list(item.get("summary_subclaims", []))
+
+        # ---------------------------------------------------------
+        # METRICS CALCULATION (Now passing id and error_log)
+        # ---------------------------------------------------------
+        
+        # Attribution: Generated Subclaims -> Full Text
+        attr_easy = calculate_metric(easy_subs, fulltext, "attribution", current_id, global_error_log)
+        attr_inter = calculate_metric(inter_subs, fulltext, "attribution", current_id, global_error_log)
+        attr_hard = calculate_metric(hard_subs, fulltext, "attribution", current_id, global_error_log)
+
+        # Conciseness: Generated Subclaims -> Summary Text
+        conc_easy = calculate_metric(easy_subs, summary, "conciseness", current_id, global_error_log)
+        conc_inter = calculate_metric(inter_subs, summary, "conciseness", current_id, global_error_log)
+        conc_hard = calculate_metric(hard_subs, summary, "conciseness", current_id, global_error_log)
+
+        # Completeness: summary Subclaims -> Generated Text
+        comp_easy = calculate_metric(summary_subs, easy_text, "completeness", current_id, global_error_log)
+        comp_inter = calculate_metric(summary_subs, inter_text, "completeness", current_id, global_error_log)
+        comp_hard = calculate_metric(summary_subs, hard_text, "completeness", current_id, global_error_log)
+
+        # Construct Output
+        result_item = item.copy()
+        result_item["metrics"] = {
+            "easy": {
+                "attribution": attr_easy,
+                "conciseness": conc_easy,
+                "completeness": comp_easy
+            },
+            "intermediate": {
+                "attribution": attr_inter,
+                "conciseness": conc_inter,
+                "completeness": comp_inter
+            },
+            "hard": {
+                "attribution": attr_hard,
+                "conciseness": conc_hard,
+                "completeness": comp_hard
+            }
+        }
+        
+        processed_results.append(result_item)
+
+        # Update progress bar with error count
+        if len(global_error_log) > 0:
+            pbar.set_postfix({"Errors": len(global_error_log)})
+
+        # Save frequently
+        if len(processed_results) % 10 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(processed_results, f, indent=4, ensure_ascii=False)
+
+    # Final Save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(processed_results, f, indent=4, ensure_ascii=False)
+
+    print(f"Evaluation for range {start}:{end} complete. Saved to: {OUTPUT_FILE}")
+
+    # -----------------------------
+    # Error Reporting
+    # -----------------------------
+    if global_error_log:
+        print(f"\n⚠️  WARNING: {len(global_error_log)} API errors occurred during processing.")
+        with open(ERROR_LOG_FILE, "w") as f:
+            json.dump(global_error_log, f, indent=4)
+        print(f"Error details saved to: {ERROR_LOG_FILE}")
+    else:
+        print("\n✅ Success: No API errors detected.")

code/finetune-inference/subclaim_support_extraction/old/subclaim_support_cal_v5.py

@@ -0,0 +1,281 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/Mistral-Small-3.1-24B_subclaims-support-check-8b_ctx_v2-bf16"
+API_URL = "http://172.16.34.29:8004/v1" 
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  VERIFICATION PROMPT
+# -----------------------------
+def inference_prompt(text, subclaim):
+    return f"""You are a clinical evidence auditor. Your evaluation must be based STRICTLY and ONLY on the provided medical text. 
+
+### MANDATORY GROUNDING RULES:
+1. NO OUTSIDE KNOWLEDGE: Do not use your internal medical knowledge. Even if a subclaim is "common sense" in medicine, if it is not explicitly in the TEXT, it is 'not_supported'.
+2. NO LOGICAL LEAPS: Do not bridge gaps in logic. (e.g., If the text mentions "high blood sugar" but not the word "diabetes", you cannot support a claim of "diabetes").
+3. EXACT NUMERICAL MATCHING: Any doses (e.g., 500mg), frequencies (e.g., twice daily), or durations (e.g., 10 days) mentioned in the subclaim must match the text perfectly. If they are missing or different in the text, label as 'not_supported'.
+4. DEFAULT TO NOT SUPPORTED: If the text is vague, ambiguous, or only suggests a possibility, you MUST choose 'not_supported'. 
+5. CLOSED-WORLD REALITY: Treat the TEXT as the only information that exists in the world.
+
+### Medical Text:
+{text}
+
+### Subclaim:
+{subclaim}
+
+Output exactly one word ('supported' or 'not_supported') based on the strict rules above:"""
+
+# -----------------------------
+#  VERIFICATION LOGIC
+# -----------------------------
+def check_support(text: str, subclaim: str, item_id=None, error_log=None) -> str:
+    """
+    Returns: 'supported', 'refuted', or 'not_supported'
+    Tracks errors in error_log if provided.
+    """
+    if not text or not subclaim:
+        return "not_supported"
+
+    prompt = inference_prompt(text, subclaim)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_PATH,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=512, 
+            temperature=0.1,
+        )
+        res = response.choices[0].message.content
+        if "</think>" in res:
+            res = res.split("</think>")[1].strip().lower()
+        else:
+            res = response.choices[0].message.content.strip().lower()
+
+        if "not_supported" in res:
+            return "not_supported"
+        elif "supported" in res:
+            return "supported"
+        elif "refuted" in res:
+            return "refuted"
+        else:
+            return "not_supported"
+
+    except Exception as e:
+        # --- ERROR TRACKING ---
+        if error_log is not None:
+            error_details = {
+                "id": item_id,
+                "subclaim": subclaim,
+                "error_msg": str(e),
+                "type": "API_ERROR"
+            }
+            error_log.append(error_details)
+        # ----------------------
+        
+        # Optional: Print to console so you see it happening live
+        print(f"\n[!] Error on ID {item_id}: {e}")
+        return "not_supported"
+
+def calculate_metric(subclaims_list: list, reference_text: str, metric_name: str, item_id=None, error_log=None):
+    if not subclaims_list:
+        return {"score": 0.0, "details": []}
+    
+    results = []
+    supported_count = 0
+
+    for subclaim in subclaims_list:
+        # Pass tracking info down to check_support
+        label = check_support(reference_text, subclaim, item_id=item_id, error_log=error_log)
+        
+        is_supported = (label == "supported")
+        
+        if is_supported:
+            supported_count += 1
+            
+        results.append({
+            "subclaim": subclaim,
+            "label": label
+        })
+
+    score = supported_count / len(subclaims_list) if len(subclaims_list) > 0 else 0.0
+    
+    return {
+        "score": score,
+        "details": results
+    }
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_full_data.json",
+                        help="Path to input JSON with subclaims")
+    
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/concise_complete_attr_testing",
+                        help="Folder to save results")
+
+    # Range arguments
+    parser.add_argument("--start_index", type=int, default=0, help="Start index")
+    parser.add_argument("--end_index", type=int, default=6, help="End index (exclusive). -1 for all.")
+
+    args = parser.parse_args()
+
+    INPUT_FILE = args.input_file
+    SAVE_FOLDER = args.save_folder
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    # -----------------------------
+    # Load Data
+    # -----------------------------
+    print(f"Loading data from {INPUT_FILE}...")
+    with open(INPUT_FILE, "r") as f:
+        all_data = json.load(f)
+
+    # -----------------------------
+    # Slice Data based on Range
+    # -----------------------------
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    
+    if end > total_len:
+        end = total_len
+
+    data_slice = all_data[start:end]
+
+    print(f"Total dataset size: {total_len}")
+    print(f"Processing range: {start} to {end}")
+    print(f"Items in this batch: {len(data_slice)}")
+
+    # -----------------------------
+    # Output Files
+    # -----------------------------
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"evaluated_metrics_{start}_{end}_mistral31_24B_v2.json")
+    ERROR_LOG_FILE = os.path.join(SAVE_FOLDER, f"error_log_{start}_{end}_mistral31_24B_v2.json")
+
+    # -----------------------------
+    # Resume Logic
+    # -----------------------------
+    processed_results = []
+    if os.path.exists(OUTPUT_FILE):
+        print(f"Found existing output file: {OUTPUT_FILE}. Resuming...")
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                processed_results = json.load(f)
+        except:
+            processed_results = []
+    
+    processed_ids = {item['id'] for item in processed_results}
+    to_process = [item for item in data_slice if item['id'] not in processed_ids]
+
+    print(f"Already processed in this file: {len(processed_ids)}")
+    print(f"Remaining to process: {len(to_process)}")
+
+    # -----------------------------
+    # Initialize Error Tracker
+    # -----------------------------
+    global_error_log = []
+
+    # -----------------------------
+    # Processing Loop
+    # -----------------------------
+    # Added tqdm postfix to show error count in real-time
+    pbar = tqdm.tqdm(to_process)
+    
+    for item in pbar:
+        current_id = item.get('id', 'unknown')
+        
+        # 1. Prepare Texts
+        easy_text = item.get("easy_text", "")
+        inter_text = item.get("intermediate_text", "")
+        hard_text = item.get("hard_text", "")
+        fulltext = item.get("fulltext", "")
+        summary = item.get("summary", "")
+
+        # 2. Prepare Subclaim Lists
+        def ensure_list(x): return x if isinstance(x, list) else []
+        
+        easy_subs = ensure_list(item.get("easy_subclaims", []))
+        inter_subs = ensure_list(item.get("intermediate_subclaims", []))
+        hard_subs = ensure_list(item.get("hard_subclaims", []))
+        full_subs = ensure_list(item.get("fulltext_subclaims", [])) 
+        summary_subs = ensure_list(item.get("summary_subclaims", []))
+
+        # ---------------------------------------------------------
+        # METRICS CALCULATION (Now passing id and error_log)
+        # ---------------------------------------------------------
+        
+        # Attribution: Generated Subclaims -> Full Text
+        attr_easy = calculate_metric(easy_subs, fulltext, "attribution", current_id, global_error_log)
+        attr_inter = calculate_metric(inter_subs, fulltext, "attribution", current_id, global_error_log)
+        attr_hard = calculate_metric(hard_subs, fulltext, "attribution", current_id, global_error_log)
+
+        # Conciseness: Generated Subclaims -> Summary Text
+        conc_easy = calculate_metric(easy_subs, summary, "conciseness", current_id, global_error_log)
+        conc_inter = calculate_metric(inter_subs, summary, "conciseness", current_id, global_error_log)
+        conc_hard = calculate_metric(hard_subs, summary, "conciseness", current_id, global_error_log)
+
+        # Completeness: summary Subclaims -> Generated Text
+        comp_easy = calculate_metric(summary_subs, easy_text, "completeness", current_id, global_error_log)
+        comp_inter = calculate_metric(summary_subs, inter_text, "completeness", current_id, global_error_log)
+        comp_hard = calculate_metric(summary_subs, hard_text, "completeness", current_id, global_error_log)
+
+        # Construct Output
+        result_item = item.copy()
+        result_item["metrics"] = {
+            "easy": {
+                "attribution": attr_easy,
+                "conciseness": conc_easy,
+                "completeness": comp_easy
+            },
+            "intermediate": {
+                "attribution": attr_inter,
+                "conciseness": conc_inter,
+                "completeness": comp_inter
+            },
+            "hard": {
+                "attribution": attr_hard,
+                "conciseness": conc_hard,
+                "completeness": comp_hard
+            }
+        }
+        
+        processed_results.append(result_item)
+
+        # Update progress bar with error count
+        if len(global_error_log) > 0:
+            pbar.set_postfix({"Errors": len(global_error_log)})
+
+        # Save frequently
+        if len(processed_results) % 10 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(processed_results, f, indent=4, ensure_ascii=False)
+
+    # Final Save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(processed_results, f, indent=4, ensure_ascii=False)
+
+    print(f"Evaluation for range {start}:{end} complete. Saved to: {OUTPUT_FILE}")
+
+    # -----------------------------
+    # Error Reporting
+    # -----------------------------
+    if global_error_log:
+        print(f"\n⚠️  WARNING: {len(global_error_log)} API errors occurred during processing.")
+        with open(ERROR_LOG_FILE, "w") as f:
+            json.dump(global_error_log, f, indent=4)
+        print(f"Error details saved to: {ERROR_LOG_FILE}")
+    else:
+        print("\n✅ Success: No API errors detected.")

code/finetune-inference/subclaim_support_extraction/readctrl_model.code-workspace

@@ -0,0 +1,18 @@
+{
+	"folders": [
+		{
+			"path": "../../../../readctrl_model"
+		},
+		{
+			"path": "../../.."
+		}
+	],
+	"settings": {
+		"folder-color.pathColors": [
+			{
+				"folderPath": "/home/mshahidul/readctrl/data/thresold_finding/",
+				"badge": "🥶"
+			}
+		]
+	}
+}

code/finetune-inference/subclaim_support_extraction/subclaim_support_cal_tesing.py

@@ -0,0 +1,199 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-support-check-8b_ctx_v2-bf16"
+model_name="qwen3-32B"
+API_URL = "http://172.16.34.29:8004/v1" 
+API_KEY = "EMPTY"
+print(f"Using model: {MODEL_PATH}")
+print(f"Model name: {model_name}")
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  VERIFICATION PROMPT
+# -----------------------------
+def inference_prompt(text, subclaim):
+    return f"""You are a clinical evidence auditor. Your evaluation must be based STRICTLY and ONLY on the provided medical text. 
+
+### MANDATORY GROUNDING RULES:
+1. NO OUTSIDE KNOWLEDGE: Do not use your internal medical knowledge. Even if a subclaim is "common sense" in medicine, if it is not explicitly in the TEXT, it is 'not_supported'.
+2. NO LOGICAL LEAPS: Do not bridge gaps in logic. (e.g., If the text mentions "high blood sugar" but not the word "diabetes", you cannot support a claim of "diabetes").
+3. EXACT NUMERICAL MATCHING: Any doses (e.g., 500mg), frequencies (e.g., twice daily), or durations (e.g., 10 days) mentioned in the subclaim must match the text perfectly. If they are missing or different in the text, label as 'not_supported'.
+4. DEFAULT TO NOT SUPPORTED: If the text is vague, ambiguous, or only suggests a possibility, you MUST choose 'not_supported'. 
+5. CLOSED-WORLD REALITY: Treat the TEXT as the only information that exists in the world.
+
+### Medical Text:
+{text}
+
+### Subclaim:
+{subclaim}
+
+Output exactly one word ('supported' or 'not_supported') based on the strict rules above:"""
+
+# -----------------------------
+#  VERIFICATION LOGIC
+# -----------------------------
+def check_support(text: str, subclaim: str, error_log=None) -> str:
+    """
+    Returns: 'supported', 'refuted', or 'not_supported'
+    Tracks errors in error_log if provided.
+    """
+    if not text or not subclaim:
+        return "not_supported"
+
+    prompt = inference_prompt(text, subclaim)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_PATH,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=100, 
+            temperature=0.1,
+        )
+        res = response.choices[0].message.content
+        if "</think>" in res:
+            res = res.split("</think>")[1].strip().lower()
+        else:
+            res = response.choices[0].message.content.strip().lower()
+
+        if "not_supported" in res:
+            return "not_supported"
+        elif "supported" in res:
+            return "supported"
+        elif "refuted" in res:
+            return "refuted"
+        else:
+            return "not_supported"
+
+    except Exception as e:
+        # --- ERROR TRACKING ---
+        if error_log is not None:
+            error_details = {
+                "subclaim": subclaim,
+                "error_msg": str(e),
+                "type": "API_ERROR"
+            }
+            error_log.append(error_details)
+        # ----------------------
+        
+        # Optional: Print to console so you see it happening live
+        # print(f"\n[!] Error on ID {item_id}: {e}")
+        return "not_supported"
+
+
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/finetuning_data/test_subclaim_support_v2.json",
+                        help="Path to input JSON with subclaims")
+    
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/concise_complete_attr_testing",
+                        help="Folder to save results")
+
+    # Range arguments
+    parser.add_argument("--start_index", type=int, default=0, help="Start index")
+    parser.add_argument("--end_index", type=int, default=-1, help="End index (exclusive). -1 for all.")
+
+    args = parser.parse_args()
+
+    INPUT_FILE = args.input_file
+    SAVE_FOLDER = args.save_folder
+    os.makedirs(SAVE_FOLDER, exist_ok=True)
+
+    # -----------------------------
+    # Load Data
+    # -----------------------------
+    print(f"Loading data from {INPUT_FILE}...")
+    with open(INPUT_FILE, "r") as f:
+        all_data = json.load(f)
+
+    # -----------------------------
+    # Slice Data based on Range
+    # -----------------------------
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    
+    if end > total_len:
+        end = total_len
+
+    data_slice = all_data[start:end]
+
+    print(f"Total dataset size: {total_len}")
+    print(f"Processing range: {start} to {end}")
+    print(f"Items in this batch: {len(data_slice)}")
+
+    # -----------------------------
+    # Output Files
+    # -----------------------------
+    OUTPUT_FILE = os.path.join(SAVE_FOLDER, f"evaluated_metrics_{start}_{end}_{model_name}_v2.json")
+   
+
+    # -----------------------------
+    # Resume Logic
+    # -----------------------------
+    processed_results = []
+    if os.path.exists(OUTPUT_FILE):
+        print(f"Found existing output file: {OUTPUT_FILE}. Resuming...")
+        try:
+            with open(OUTPUT_FILE, "r") as f:
+                processed_results = json.load(f)
+        except:
+            processed_results = []
+    
+    processed_ids = {item['medical_text'] for item in processed_results}
+    to_process = [item for item in data_slice if item['medical_text'] not in processed_ids]
+
+    print(f"Already processed in this file: {len(processed_ids)}")
+    print(f"Remaining to process: {len(to_process)}")
+
+    # -----------------------------
+    # Initialize Error Tracker
+    # -----------------------------
+    global_error_log = []
+
+    # -----------------------------
+    # Processing Loop
+    # -----------------------------
+    # Added tqdm postfix to show error count in real-time
+    pbar = tqdm.tqdm(to_process)
+    
+    for item in pbar:
+        text=item.get('medical_text', '')
+        subclaim=item.get('subclaim', [])
+        label_gt=item.get('label', 'not_supported')
+        correctness=False
+        label_gen=check_support(text, subclaim, error_log=global_error_log)
+        if "not_supported" in label_gen and "not_supported" in label_gt:
+            correctness=True
+        elif "supported" in label_gen and "supported" in label_gt:
+            correctness=True
+        else:
+            print(f"Mismatch:\nGT: {label_gt}\nGEN: {label_gen}\nSubclaim: {subclaim}\nText: {text}\n---")
+        result_entry={
+            "medical_text": text,
+            "subclaim": subclaim,
+            "label_gt": label_gt,
+            "label_gen": label_gen,
+            "correctness": correctness
+        }
+        processed_results.append(result_entry)
+        if len(processed_results) % 10 == 0:
+            # Save intermediate results
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(processed_results, f, indent=2, ensure_ascii=False)
+
+
+with open(OUTPUT_FILE, "w") as f:
+    json.dump(processed_results, f, indent=2, ensure_ascii=False)

code/finetune-inference/subclaim_support_extraction/subclaim_support_cal_tesing_v2.py

@@ -0,0 +1,138 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+# Updated to reflect your specific project paths
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-support-check-8b_ctx_v2-bf16"
+model_name = "qwen3-32B"
+API_URL = "http://172.16.34.29:8004/v1" 
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  VERIFICATION PROMPT
+# -----------------------------
+def inference_prompt(text, subclaim):
+    return f"""You are a clinical evidence auditor. Your evaluation must be based STRICTLY and ONLY on the provided medical text. 
+
+### MANDATORY GROUNDING RULES:
+1. NO OUTSIDE KNOWLEDGE: Do not use your internal medical knowledge.
+2. NO LOGICAL LEAPS: Do not bridge gaps in logic.
+3. EXACT NUMERICAL MATCHING: Any doses, frequencies, or durations must match the text perfectly.
+4. DEFAULT TO NOT SUPPORTED: If the text is vague or ambiguous, you MUST choose 'not_supported'. 
+5. CLOSED-WORLD REALITY: Treat the TEXT as the only information that exists in the world.
+
+### Medical Text:
+{text}
+
+### Subclaim:
+{subclaim}
+
+Output exactly one word ('supported' or 'not_supported') based on the strict rules above:"""
+
+# -----------------------------
+#  VERIFICATION LOGIC
+# -----------------------------
+def check_support(text: str, subclaim: str) -> str:
+    if not text or not subclaim:
+        return "not_supported"
+
+    prompt = inference_prompt(text, subclaim)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_PATH,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=10, # Shortened as we only need one word
+            temperature=0.1,
+        )
+        res = response.choices[0].message.content.strip().lower()
+        
+        # Handle reasoning models that might include <think> tags
+        if "</think>" in res:
+            res = res.split("</think>")[-1].strip()
+
+        if "not_supported" in res:
+            return "not_supported"
+        elif "supported" in res:
+            return "supported"
+        return "not_supported"
+
+    except Exception as e:
+        return "error_api"
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_classified_multiclinsum_test_en_en.json")
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/factual_testing")
+    parser.add_argument("--start_index", type=int, default=0)
+    parser.add_argument("--end_index", type=int, default=-1)
+
+    args = parser.parse_args()
+    os.makedirs(args.save_folder, exist_ok=True)
+
+    print(f"Loading data from {args.input_file}...")
+    with open(args.input_file, "r") as f:
+        all_data = json.load(f)
+
+    # Slice Data
+    total_len = len(all_data)
+    start = args.start_index
+    end = args.end_index if args.end_index != -1 else total_len
+    data_slice = all_data[start:end]
+
+    OUTPUT_FILE = os.path.join(args.save_folder, f"evaluated_support_{start}_{end}_{model_name}.json")
+
+    processed_results = []
+    # Simple resume logic by checking length
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE, "r") as f:
+            processed_results = json.load(f)
+        print(f"Resuming from index {len(processed_results)}")
+        data_slice = data_slice[len(processed_results):]
+
+    for item in tqdm.tqdm(data_slice):
+        doc_id = item.get('id', 'unknown')
+        full_text = item.get('fulltext', '')
+        # We usually want to verify if the summary's claims are supported by the full text
+        summary_subclaims = item.get('summary_subclaims', [])
+        
+        results_for_this_doc = []
+        
+        # summary_subclaims is likely a list of strings
+        for sc in summary_subclaims:
+            label_gen = check_support(full_text, sc)
+            results_for_this_doc.append({
+                "subclaim": sc,
+                "support_label": label_gen
+            })
+
+        output_entry = {
+            "id": doc_id,
+            "fulltext": full_text,
+            "summary": item.get('summary', ''),
+            "subclaim_evaluations": results_for_this_doc
+        }
+        
+        processed_results.append(output_entry)
+
+        # Periodic save
+        if len(processed_results) % 10 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(processed_results, f, indent=2, ensure_ascii=False)
+
+    # Final save
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(processed_results, f, indent=2, ensure_ascii=False)
+    print(f"Processing complete. Saved to {OUTPUT_FILE}")

code/finetune-inference/subclaim_support_extraction/subclaim_support_cal_tesing_v3.py

@@ -0,0 +1,131 @@
+import os
+import json
+import tqdm
+import argparse
+from openai import OpenAI
+
+# -----------------------------
+#  CONFIGURATION
+# -----------------------------
+MODEL_PATH = "/home/mshahidul/readctrl_model/full_model/qwen3-32B_subclaims-support-check-8b_ctx_v2-bf16"
+model_name = "qwen3-32B"
+API_URL = "http://172.16.34.29:8004/v1" 
+API_KEY = "EMPTY"
+
+client = OpenAI(base_url=API_URL, api_key=API_KEY)
+
+# -----------------------------
+#  PROMPTS
+# -----------------------------
+
+def get_attribution_prompt(source_text, subclaim):
+    """Checks if summary subclaim is grounded in source."""
+    return f"""You are a clinical evidence auditor. 
+### Medical Text (Source):
+{source_text}
+### Subclaim (from Summary):
+{subclaim}
+Output exactly one word ('supported' or 'not_supported') if the Source text contains the info in the Subclaim:"""
+
+def get_completeness_prompt(summary_text, source_subclaim):
+    """Checks if a key source fact is present in the summary."""
+    return f"""You are checking for information loss in a medical summary.
+### Summary Text:
+{summary_text}
+### Key Fact (from Source):
+{source_subclaim}
+Output exactly one word ('supported' or 'not_supported') if the Summary successfully includes the info from the Key Fact:"""
+
+# -----------------------------
+#  LOGIC
+# -----------------------------
+
+def check_support(context: str, subclaim: str, mode="attribution") -> str:
+    if not context or not subclaim:
+        return "not_supported"
+
+    if mode == "attribution":
+        prompt = get_attribution_prompt(context, subclaim)
+    else: # completeness
+        prompt = get_completeness_prompt(context, subclaim)
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_PATH,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=10,
+            temperature=0.1,
+        )
+        res = response.choices[0].message.content.strip().lower()
+        
+        if "</think>" in res:
+            res = res.split("</think>")[-1].strip()
+
+        return "supported" if "supported" in res and "not_supported" not in res else "not_supported"
+    except Exception:
+        return "error_api"
+
+# -----------------------------
+#  MAIN
+# -----------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", type=str, 
+                        default="/home/mshahidul/readctrl/data/extracting_subclaim/extracted_subclaims_classified_multiclinsum_test_en_en.json")
+    parser.add_argument("--save_folder", type=str, 
+                        default="/home/mshahidul/readctrl/data/factual_testing")
+    parser.add_argument("--start_index", type=int, default=0)
+    parser.add_argument("--end_index", type=int, default=-1)
+
+    args = parser.parse_args()
+    os.makedirs(args.save_folder, exist_ok=True)
+
+    with open(args.input_file, "r") as f:
+        all_data = json.load(f)
+
+    start, end = args.start_index, (args.end_index if args.end_index != -1 else len(all_data))
+    data_slice = all_data[start:end]
+    OUTPUT_FILE = os.path.join(args.save_folder, f"full_evaluation_{start}_{end}_{model_name}.json")
+
+    processed_results = []
+
+    for item in tqdm.tqdm(data_slice):
+        full_text = item.get('fulltext', '')
+        summary = item.get('summary', '')
+        
+        # 1. Factual Attribution (Summary -> Source)
+        summary_subclaims = item.get('summary_subclaims', [])
+        attribution_results = []
+        for sc in summary_subclaims:
+            label = check_support(full_text, sc, mode="attribution")
+            attribution_results.append({"subclaim": sc, "label": label})
+
+        # 2. Completeness Check (Source -> Summary)
+        # Assuming you have already extracted subclaims from the fulltext in your JSON
+        source_subclaims = item.get('fulltext_subclaims', []) 
+        completeness_results = []
+        for sc in source_subclaims:
+            label = check_support(summary, sc, mode="completeness")
+            completeness_results.append({"source_fact": sc, "present_in_summary": label})
+
+        # Calculate scores
+        attr_score = sum(1 for x in attribution_results if x['label'] == 'supported') / len(attribution_results) if attribution_results else 0
+        comp_score = sum(1 for x in completeness_results if x['present_in_summary'] == 'supported') / len(completeness_results) if completeness_results else 0
+
+        processed_results.append({
+            "id": item.get('id', 'unknown'),
+            "scores": {
+                "factual_attribution": attr_score,
+                "completeness": comp_score
+            },
+            "attribution_details": attribution_results,
+            "completeness_details": completeness_results
+        })
+
+        if len(processed_results) % 5 == 0:
+            with open(OUTPUT_FILE, "w") as f:
+                json.dump(processed_results, f, indent=2)
+
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(processed_results, f, indent=2)
+    print(f"Done. Saved to {OUTPUT_FILE}")