NextGenC commited on Apr 20, 2025

Commit

64b5d29

verified ·

1 Parent(s): 96f3b39

Upload 27 files

Browse files

Files changed (27) hide show

2025-04-15_Introduction_to_Artificial_Intelligence.pdf +0 -0
analysis_concept_frequencies.parquet +3 -0
analysis_concept_similarities.parquet +3 -0
analysis_network_results.parquet +3 -0
bestTest.png +0 -0
concept_embeddings.pkl +3 -0
concept_network.pkl +3 -0
concept_network_visualization.html +374 -0
concept_similarities.parquet +3 -0
concepts.parquet +3 -0
documents.parquet +3 -0
extractor.py +197 -0
loaders.py +136 -0
mentions.parquet +3 -0
network_analysis.py +154 -0
network_builder.py +118 -0
plotting.py +155 -0
relationships.parquet +3 -0
requirements.txt +2 -0
reset_status.py +24 -0
run_analysis.py +125 -0
run_extractor.py +15 -0
run_loader.py +14 -0
similarity.py +170 -0
storage.py +150 -0
temporal.py +164 -0
test1.png +0 -0

2025-04-15_Introduction_to_Artificial_Intelligence.pdf ADDED Viewed

Binary file (53.3 kB). View file

analysis_concept_frequencies.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:31cb3e93a0c0c1eb3f65ba695a75b03bdd2b67f80fefd9b7810497ec50100d42
+size 3618

analysis_concept_similarities.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:0cf17175e4b6a3fac9648e20938ce6c90e4d90dbdc1c71186846a17eff77b45a
+size 4846

analysis_network_results.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:98e8ca5669f2a601c184388dda9b34d870ef5a35e69336a4bc23adff7ffc14c2
+size 5022

bestTest.png ADDED Viewed

concept_embeddings.pkl ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:aa1f484881118bfd68ca830e070e85c0e380a1be6bbef1c637ea17303bc4d167
+size 17716

concept_network.pkl ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:acc729f59905a3394915ccb0d731ba2bc1a25b2a16f7cd524cb1cdfa451420db
+size 2336

concept_network_visualization.html ADDED Viewed

	@@ -0,0 +1,374 @@

+<html>
+    <head>
+        <meta charset="utf-8">
+            <script>function neighbourhoodHighlight(params) {
+  // console.log("in nieghbourhoodhighlight");
+  allNodes = nodes.get({ returnType: "Object" });
+  // originalNodes = JSON.parse(JSON.stringify(allNodes));
+  // if something is selected:
+  if (params.nodes.length > 0) {
+    highlightActive = true;
+    var i, j;
+    var selectedNode = params.nodes[0];
+    var degrees = 2;
+    // mark all nodes as hard to read.
+    for (let nodeId in allNodes) {
+      // nodeColors[nodeId] = allNodes[nodeId].color;
+      allNodes[nodeId].color = "rgba(200,200,200,0.5)";
+      if (allNodes[nodeId].hiddenLabel === undefined) {
+        allNodes[nodeId].hiddenLabel = allNodes[nodeId].label;
+        allNodes[nodeId].label = undefined;
+      }
+    }
+    var connectedNodes = network.getConnectedNodes(selectedNode);
+    var allConnectedNodes = [];
+    // get the second degree nodes
+    for (i = 1; i < degrees; i++) {
+      for (j = 0; j < connectedNodes.length; j++) {
+        allConnectedNodes = allConnectedNodes.concat(
+          network.getConnectedNodes(connectedNodes[j])
+        );
+      }
+    }
+    // all second degree nodes get a different color and their label back
+    for (i = 0; i < allConnectedNodes.length; i++) {
+      // allNodes[allConnectedNodes[i]].color = "pink";
+      allNodes[allConnectedNodes[i]].color = "rgba(150,150,150,0.75)";
+      if (allNodes[allConnectedNodes[i]].hiddenLabel !== undefined) {
+        allNodes[allConnectedNodes[i]].label =
+          allNodes[allConnectedNodes[i]].hiddenLabel;
+        allNodes[allConnectedNodes[i]].hiddenLabel = undefined;
+      }
+    }
+    // all first degree nodes get their own color and their label back
+    for (i = 0; i < connectedNodes.length; i++) {
+      // allNodes[connectedNodes[i]].color = undefined;
+      allNodes[connectedNodes[i]].color = nodeColors[connectedNodes[i]];
+      if (allNodes[connectedNodes[i]].hiddenLabel !== undefined) {
+        allNodes[connectedNodes[i]].label =
+          allNodes[connectedNodes[i]].hiddenLabel;
+        allNodes[connectedNodes[i]].hiddenLabel = undefined;
+      }
+    }
+    // the main node gets its own color and its label back.
+    // allNodes[selectedNode].color = undefined;
+    allNodes[selectedNode].color = nodeColors[selectedNode];
+    if (allNodes[selectedNode].hiddenLabel !== undefined) {
+      allNodes[selectedNode].label = allNodes[selectedNode].hiddenLabel;
+      allNodes[selectedNode].hiddenLabel = undefined;
+    }
+  } else if (highlightActive === true) {
+    // console.log("highlightActive was true");
+    // reset all nodes
+    for (let nodeId in allNodes) {
+      // allNodes[nodeId].color = "purple";
+      allNodes[nodeId].color = nodeColors[nodeId];
+      // delete allNodes[nodeId].color;
+      if (allNodes[nodeId].hiddenLabel !== undefined) {
+        allNodes[nodeId].label = allNodes[nodeId].hiddenLabel;
+        allNodes[nodeId].hiddenLabel = undefined;
+      }
+    }
+    highlightActive = false;
+  }
+  // transform the object into an array
+  var updateArray = [];
+  if (params.nodes.length > 0) {
+    for (let nodeId in allNodes) {
+      if (allNodes.hasOwnProperty(nodeId)) {
+        // console.log(allNodes[nodeId]);
+        updateArray.push(allNodes[nodeId]);
+      }
+    }
+    nodes.update(updateArray);
+  } else {
+    // console.log("Nothing was selected");
+    for (let nodeId in allNodes) {
+      if (allNodes.hasOwnProperty(nodeId)) {
+        // console.log(allNodes[nodeId]);
+        // allNodes[nodeId].color = {};
+        updateArray.push(allNodes[nodeId]);
+      }
+    }
+    nodes.update(updateArray);
+  }
+}
+function filterHighlight(params) {
+  allNodes = nodes.get({ returnType: "Object" });
+  // if something is selected:
+  if (params.nodes.length > 0) {
+    filterActive = true;
+    let selectedNodes = params.nodes;
+    // hiding all nodes and saving the label
+    for (let nodeId in allNodes) {
+      allNodes[nodeId].hidden = true;
+      if (allNodes[nodeId].savedLabel === undefined) {
+        allNodes[nodeId].savedLabel = allNodes[nodeId].label;
+        allNodes[nodeId].label = undefined;
+      }
+    }
+    for (let i=0; i < selectedNodes.length; i++) {
+      allNodes[selectedNodes[i]].hidden = false;
+      if (allNodes[selectedNodes[i]].savedLabel !== undefined) {
+        allNodes[selectedNodes[i]].label = allNodes[selectedNodes[i]].savedLabel;
+        allNodes[selectedNodes[i]].savedLabel = undefined;
+      }
+    }
+  } else if (filterActive === true) {
+    // reset all nodes
+    for (let nodeId in allNodes) {
+      allNodes[nodeId].hidden = false;
+      if (allNodes[nodeId].savedLabel !== undefined) {
+        allNodes[nodeId].label = allNodes[nodeId].savedLabel;
+        allNodes[nodeId].savedLabel = undefined;
+      }
+    }
+    filterActive = false;
+  }
+  // transform the object into an array
+  var updateArray = [];
+  if (params.nodes.length > 0) {
+    for (let nodeId in allNodes) {
+      if (allNodes.hasOwnProperty(nodeId)) {
+        updateArray.push(allNodes[nodeId]);
+      }
+    }
+    nodes.update(updateArray);
+  } else {
+    for (let nodeId in allNodes) {
+      if (allNodes.hasOwnProperty(nodeId)) {
+        updateArray.push(allNodes[nodeId]);
+      }
+    }
+    nodes.update(updateArray);
+  }
+}
+function selectNode(nodes) {
+  network.selectNodes(nodes);
+  neighbourhoodHighlight({ nodes: nodes });
+  return nodes;
+}
+function selectNodes(nodes) {
+  network.selectNodes(nodes);
+  filterHighlight({nodes: nodes});
+  return nodes;
+}
+function highlightFilter(filter) {
+  let selectedNodes = []
+  let selectedProp = filter['property']
+  if (filter['item'] === 'node') {
+    let allNodes = nodes.get({ returnType: "Object" });
+    for (let nodeId in allNodes) {
+      if (allNodes[nodeId][selectedProp] && filter['value'].includes((allNodes[nodeId][selectedProp]).toString())) {
+        selectedNodes.push(nodeId)
+      }
+    }
+  }
+  else if (filter['item'] === 'edge'){
+    let allEdges = edges.get({returnType: 'object'});
+    // check if the selected property exists for selected edge and select the nodes connected to the edge
+    for (let edge in allEdges) {
+      if (allEdges[edge][selectedProp] && filter['value'].includes((allEdges[edge][selectedProp]).toString())) {
+        selectedNodes.push(allEdges[edge]['from'])
+        selectedNodes.push(allEdges[edge]['to'])
+      }
+    }
+  }
+  selectNodes(selectedNodes)
+}</script>
+            <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/dist/vis-network.min.css" integrity="sha512-WgxfT5LWjfszlPHXRmBWHkV2eceiWTOBvrKCNbdgDYTHrT2AeLCGbF4sZlZw3UMN3WtL0tGUoIAKsu8mllg/XA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/vis-network.min.js" integrity="sha512-LnvoEWDFrqGHlHmDD2101OrLcbsfkrzoSpvtSQtxK3RMnRV0eOkhhBN2dXHKRrUU8p2DGRTk35n4O8nWSVe1mQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+<center>
+<h1>ChronoSense Konsept A�� (Metriklerle)</h1>
+</center>
+<!-- <link rel="stylesheet" href="../node_modules/vis/dist/vis.min.css" type="text/css" />
+<script type="text/javascript" src="../node_modules/vis/dist/vis.js"> </script>-->
+        <link
+          href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/css/bootstrap.min.css"
+          rel="stylesheet"
+          integrity="sha384-eOJMYsd53ii+scO/bJGFsiCZc+5NDVN2yr8+0RDqr0Ql0h+rP48ckxlpbzKgwra6"
+          crossorigin="anonymous"
+        />
+        <script
+          src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta3/dist/js/bootstrap.bundle.min.js"
+          integrity="sha384-JEW9xMcG8R+pH31jmWH6WWP0WintQrMb4s7ZOdauHnUtxwoG2vI5DkLtS3qm9Ekf"
+          crossorigin="anonymous"
+        ></script>
+        <center>
+          <h1>ChronoSense Konsept A�� (Metriklerle)</h1>
+        </center>
+        <style type="text/css">
+             #mynetwork {
+                 width: 100%;
+                 height: 800px;
+                 background-color: #ffffff;
+                 border: 1px solid lightgray;
+                 position: relative;
+                 float: left;
+             }
+             #config {
+                 float: left;
+                 width: 400px;
+                 height: 600px;
+             }
+        </style>
+    </head>
+    <body>
+        <div class="card" style="width: 100%">
+            <div id="mynetwork" class="card-body"></div>
+        </div>
+            <div id="config"></div>
+        <script type="text/javascript">
+              // initialize global variables.
+              var edges;
+              var nodes;
+              var allNodes;
+              var allEdges;
+              var nodeColors;
+              var originalNodes;
+              var network;
+              var container;
+              var options, data;
+              var filter = {
+                  item : '',
+                  property : '',
+                  value : []
+              };
+              // This method is responsible for drawing the graph, returns the drawn network
+              function drawGraph() {
+                  var container = document.getElementById('mynetwork');
+                  // parsing and collecting nodes and edges from the python
+                  nodes = new vis.DataSet([{"color": "#ff7f0e", "id": "b8566bb8-f043-45d0-8442-c8f3e729a626", "label": "ai", "shape": "dot", "size": 40.0, "title": "ID: b8566bb8-f043-45d0-8442-c8f3e729a626\u003cbr\u003eName: ai\u003cbr\u003edegree_centrality: 0.300\u003cbr\u003ecommunity_id: 1"}, {"color": "#2ca02c", "id": "acdb0052-9fb5-4a61-8ce3-4fa9188ccd68", "label": "unsupervised learning: finding", "shape": "dot", "size": 40.0, "title": "ID: acdb0052-9fb5-4a61-8ce3-4fa9188ccd68\u003cbr\u003eName: unsupervised learning: finding\u003cbr\u003edegree_centrality: 0.300\u003cbr\u003ecommunity_id: 2"}, {"color": "#2ca02c", "id": "c9a071e5-358b-460f-897d-5a0d68b4dc91", "label": "reinforcement learning", "shape": "dot", "size": 40.0, "title": "ID: c9a071e5-358b-460f-897d-5a0d68b4dc91\u003cbr\u003eName: reinforcement learning\u003cbr\u003edegree_centrality: 0.300\u003cbr\u003ecommunity_id: 2"}, {"color": "#d62728", "id": "8bcb0007-453a-45a8-b0f5-ccb49fc963be", "label": "deep learning", "shape": "dot", "size": 10, "title": "ID: 8bcb0007-453a-45a8-b0f5-ccb49fc963be\u003cbr\u003eName: deep learning\u003cbr\u003edegree_centrality: 0.000\u003cbr\u003ecommunity_id: 3"}, {"color": "#1f77b4", "id": "544a779d-f9b6-4720-bfdf-80a26574d819", "label": "nlp", "shape": "dot", "size": 20.0, "title": "ID: 544a779d-f9b6-4720-bfdf-80a26574d819\u003cbr\u003eName: nlp\u003cbr\u003edegree_centrality: 0.100\u003cbr\u003ecommunity_id: 0"}, {"color": "#ff7f0e", "id": "1b3a4eb6-a80f-4098-b98e-2ca50ecbdbc6", "label": "chatbots", "shape": "dot", "size": 30.0, "title": "ID: 1b3a4eb6-a80f-4098-b98e-2ca50ecbdbc6\u003cbr\u003eName: chatbots\u003cbr\u003edegree_centrality: 0.200\u003cbr\u003ecommunity_id: 1"}, {"color": "#2ca02c", "id": "ffec4610-96c3-4a0f-a592-573143619a30", "label": "supervised learning", "shape": "dot", "size": 40.0, "title": "ID: ffec4610-96c3-4a0f-a592-573143619a30\u003cbr\u003eName: supervised learning\u003cbr\u003edegree_centrality: 0.300\u003cbr\u003ecommunity_id: 2"}, {"color": "#2ca02c", "id": "c7b69b48-9fea-45de-868d-27f935a7b2b7", "label": "labeled data unsupervised learning", "shape": "dot", "size": 40.0, "title": "ID: c7b69b48-9fea-45de-868d-27f935a7b2b7\u003cbr\u003eName: labeled data unsupervised learning\u003cbr\u003edegree_centrality: 0.300\u003cbr\u003ecommunity_id: 2"}, {"color": "#1f77b4", "id": "18f1cc03-9cfc-40c8-aa86-279a700a7f58", "label": "this approach", "shape": "dot", "size": 20.0, "title": "ID: 18f1cc03-9cfc-40c8-aa86-279a700a7f58\u003cbr\u003eName: this approach\u003cbr\u003edegree_centrality: 0.100\u003cbr\u003ecommunity_id: 0"}, {"color": "#ff7f0e", "id": "78b888f4-c0bf-492e-b514-3da1f628797d", "label": "gpt-4", "shape": "dot", "size": 30.0, "title": "ID: 78b888f4-c0bf-492e-b514-3da1f628797d\u003cbr\u003eName: gpt-4\u003cbr\u003edegree_centrality: 0.200\u003cbr\u003ecommunity_id: 1"}, {"color": "#ff7f0e", "id": "903e5742-9937-42c1-917d-ea7ff7ac449e", "label": "these models", "shape": "dot", "size": 20.0, "title": "ID: 903e5742-9937-42c1-917d-ea7ff7ac449e\u003cbr\u003eName: these models\u003cbr\u003edegree_centrality: 0.100\u003cbr\u003ecommunity_id: 1"}]);
+                  edges = new vis.DataSet([{"color": "#9370DB", "from": "b8566bb8-f043-45d0-8442-c8f3e729a626", "title": "Type: combined\u003cbr\u003eRelation: RELATED_TO\u003cbr\u003eSimilarity: 0.648", "to": "1b3a4eb6-a80f-4098-b98e-2ca50ecbdbc6", "value": 0.647527813911438}, {"color": "#9370DB", "from": "b8566bb8-f043-45d0-8442-c8f3e729a626", "title": "Type: combined\u003cbr\u003eRelation: RELATED_TO\u003cbr\u003eSimilarity: 0.648", "to": "78b888f4-c0bf-492e-b514-3da1f628797d", "value": 0.647527813911438}, {"color": "#4682B4", "from": "b8566bb8-f043-45d0-8442-c8f3e729a626", "title": "Type: similarity\u003cbr\u003eSimilarity: 0.627", "to": "903e5742-9937-42c1-917d-ea7ff7ac449e", "value": 0.6268218755722046}, {"color": "#FF6347", "from": "acdb0052-9fb5-4a61-8ce3-4fa9188ccd68", "title": "Type: extracted\u003cbr\u003eRelation: RELATED_TO", "to": "c9a071e5-358b-460f-897d-5a0d68b4dc91", "value": 0.8}, {"color": "#FF6347", "from": "acdb0052-9fb5-4a61-8ce3-4fa9188ccd68", "title": "Type: extracted\u003cbr\u003eRelation: RELATED_TO", "to": "ffec4610-96c3-4a0f-a592-573143619a30", "value": 0.8}, {"color": "#FF6347", "from": "acdb0052-9fb5-4a61-8ce3-4fa9188ccd68", "title": "Type: extracted\u003cbr\u003eRelation: RELATED_TO", "to": "c7b69b48-9fea-45de-868d-27f935a7b2b7", "value": 0.8}, {"color": "#FF6347", "from": "c9a071e5-358b-460f-897d-5a0d68b4dc91", "title": "Type: extracted\u003cbr\u003eRelation: RELATED_TO", "to": "ffec4610-96c3-4a0f-a592-573143619a30", "value": 0.8}, {"color": "#FF6347", "from": "c9a071e5-358b-460f-897d-5a0d68b4dc91", "title": "Type: extracted\u003cbr\u003eRelation: RELATED_TO", "to": "c7b69b48-9fea-45de-868d-27f935a7b2b7", "value": 0.8}, {"color": "#FF6347", "from": "544a779d-f9b6-4720-bfdf-80a26574d819", "title": "Type: extracted\u003cbr\u003eRelation: RELATED_TO", "to": "18f1cc03-9cfc-40c8-aa86-279a700a7f58", "value": 0.8}, {"color": "#FF6347", "from": "1b3a4eb6-a80f-4098-b98e-2ca50ecbdbc6", "title": "Type: extracted\u003cbr\u003eRelation: RELATED_TO", "to": "78b888f4-c0bf-492e-b514-3da1f628797d", "value": 0.8}, {"color": "#FF6347", "from": "ffec4610-96c3-4a0f-a592-573143619a30", "title": "Type: extracted\u003cbr\u003eRelation: RELATED_TO", "to": "c7b69b48-9fea-45de-868d-27f935a7b2b7", "value": 0.8}]);
+                  nodeColors = {};
+                  allNodes = nodes.get({ returnType: "Object" });
+                  for (nodeId in allNodes) {
+                    nodeColors[nodeId] = allNodes[nodeId].color;
+                  }
+                  allEdges = edges.get({ returnType: "Object" });
+                  // adding nodes and edges to the graph
+                  data = {nodes: nodes, edges: edges};
+                  var options = {
+    "configure": {
+        "enabled": true,
+        "filter": [
+            "physics",
+            "nodes",
+            "edges"
+        ]
+    },
+    "edges": {
+        "color": {
+            "inherit": true
+        },
+        "smooth": {
+            "enabled": true,
+            "type": "dynamic"
+        }
+    },
+    "interaction": {
+        "dragNodes": true,
+        "hideEdgesOnDrag": false,
+        "hideNodesOnDrag": false
+    },
+    "physics": {
+        "barnesHut": {
+            "avoidOverlap": 0,
+            "centralGravity": 0.1,
+            "damping": 0.09,
+            "gravitationalConstant": -8000,
+            "springConstant": 0.005,
+            "springLength": 150
+        },
+        "enabled": true,
+        "stabilization": {
+            "enabled": true,
+            "fit": true,
+            "iterations": 1000,
+            "onlyDynamicEdges": false,
+            "updateInterval": 50
+        }
+    }
+};
+                  // if this network requires displaying the configure window,
+                  // put it in its div
+                  options.configure["container"] = document.getElementById("config");
+                  network = new vis.Network(container, data, options);
+                  return network;
+              }
+              drawGraph();
+        </script>
+    </body>
+</html>

concept_similarities.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:d17d91d0e64c82d91352c7d178c5f0bf6d19719c3c190036fad8395f7652fa72
+size 3421

concepts.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:c8e21aae40aeb1ca4155d06f5df51e5d63be4aecb619ad8d15f7fbca58e9a7e6
+size 3200

documents.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:158b86abf339fb8862e128d62c1e64e4dc4536a3937eaf85e44e839eb12448f4
+size 3921

extractor.py ADDED Viewed

	@@ -0,0 +1,197 @@

+# src/extraction/extractor.py (AttributeError DÜZELTİLMİŞ TAM KOD)
+import spacy
+from pathlib import Path
+import logging
+import itertools
+import re
+import string
+# Yerel modüllerimizi içe aktaralım
+from src.data_management import storage
+from src.data_management import loaders # extract_text_from_pdf için
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# --- spaCy Model Yükleme ---
+nlp = None
+STOP_WORDS = set()
+try:
+    nlp = spacy.load("en_core_web_lg")
+    logging.info("spaCy 'en_core_web_lg' modeli başarıyla yüklendi.")
+    STOP_WORDS = nlp.Defaults.stop_words
+except OSError:
+    logging.error("spaCy 'en_core_web_lg' modeli bulunamadı. Lütfen indirin: python -m spacy download en_core_web_lg")
+# --- Konsept Belirleme Kriterleri (Aynı kaldı) ---
+TRUSTED_ENTITY_LABELS = {"PRODUCT", "ORG", "WORK_OF_ART"}
+OTHER_ENTITY_LABELS = {"PERSON", "EVENT", "LAW", "NORP", "FAC", "GPE", "LOC"}
+NOUN_CHUNK_PATTERNS = re.compile(r".*\b(learning|network|model|algorithm|system|technique|approach|agent|layer|architecture|transformer|attention)\b$", re.IGNORECASE)
+MIN_CONCEPT_WORDS = 1
+MAX_CONCEPT_WORDS = 6
+AI_KEYWORDS = {"artificial intelligence", "machine learning", "deep learning",
+               "neural network", "reinforcement learning", "transformer", "llm",
+               "large language model", "computer vision", "natural language processing",
+               "algorithm", "model", "gpt", "bert", "agent", "attention", "supervised",
+               "unsupervised", "classification", "regression", "clustering"}
+# --- İlişki Çıkarımı için Fiiller ve Desenler ---
+RELATION_VERBS = {
+    "use": "USES", "utilize": "USES", "apply": "USES", "employ": "USES",
+    "improve": "IMPROVES", "enhance": "IMPROVES", "extend": "IMPROVES", "outperform": "IMPROVES",
+    "base on": "BASED_ON", "rely on": "BASED_ON",
+    "compare": "COMPARES_TO", "relate": "RELATED_TO", "associate": "RELATED_TO", "link": "RELATED_TO",
+    "propose": "PROPOSES", "introduce": "PROPOSES", "develop": "PROPOSES",
+}
+def normalize_and_validate_concept(text: str, is_entity: bool = False, entity_label: str = "") -> str | None:
+    """ Verilen metni temizler, doğrular... """
+    cleaned_text = text.strip()
+    word_count = len(cleaned_text.split())
+    if not (MIN_CONCEPT_WORDS <= word_count <= MAX_CONCEPT_WORDS): return None
+    if cleaned_text and all(word.lower() in STOP_WORDS for word in re.findall(r'\b\w+\b', cleaned_text)): return None
+    if cleaned_text.isdigit() or all(c in string.punctuation for c in cleaned_text): return None
+    generic_phrases = {"this approach", "these models", "this technique", "this system",
+                       "the model", "the algorithm", "the method", "the approach",
+                       "the system", "the technique", "our model", "our approach"}
+    if cleaned_text.lower() in generic_phrases: return None
+    return cleaned_text
+def find_verb_relation(token1: spacy.tokens.Token, token2: spacy.tokens.Token) -> tuple[str, str] | None:
+    """ İki token arasındaki dependency path'e bakarak fiil ilişkisi bulur. """
+    common_ancestor = None
+    ancestors1 = list(token1.ancestors)
+    ancestors2 = list(token2.ancestors)
+    for t in reversed(ancestors1):
+        if t in ancestors2:
+            common_ancestor = t
+            break
+    if not common_ancestor: return None
+    verb1 = None; head = token1
+    while head != common_ancestor:
+        if head.pos_ == "VERB": verb1 = head; break
+        head = head.head
+    verb2 = None; head = token2
+    while head != common_ancestor:
+        if head.pos_ == "VERB": verb2 = head; break
+        head = head.head
+    verb_token = None
+    if common_ancestor.pos_ == "VERB": verb_token = common_ancestor
+    elif verb1 and verb1 == verb2: verb_token = verb1
+    # elif verb1: verb_token = verb1 # Tek taraflı fiilleri şimdilik yoksayalım
+    # elif verb2: verb_token = verb2
+    elif common_ancestor.head.pos_ == "VERB": verb_token = common_ancestor.head
+    if verb_token:
+        verb_lemma = verb_token.lemma_
+        # *** HATA DÜZELTME: Bu satırı geçici olarak kaldırıyoruz/yorum yapıyoruz ***
+        # if verb_token.is_aux or verb_token.is_stop:
+        #     return None
+        # **********************************************************************
+        for verb, rel_type in RELATION_VERBS.items():
+            if verb_lemma == verb or verb_lemma in verb.split():
+                 logging.debug(f"Fiil ilişkisi bulundu: {token1.text}... {verb_lemma} ({rel_type}) ...{token2.text}")
+                 return rel_type, verb_lemma
+    return None
+def extract_entities_and_relations(text: str, doc_id: str):
+    """ Metinden konseptleri, mention'ları ve İYİLEŞTİRİLMİŞ ilişkileri çıkarır. """
+    if not nlp: raise RuntimeError("spaCy modeli yüklenemedi.")
+    spacy_doc = nlp(text)
+    potential_concepts = {}; mentions_in_doc = []; valid_mentions = {}
+    processed_spans = set(); added_relations = set()
+    # 1. Adayları Bul
+    candidates = []
+    for ent in spacy_doc.ents:
+         if ent.label_ in TRUSTED_ENTITY_LABELS or ent.label_ in OTHER_ENTITY_LABELS:
+             candidates.append({"span": ent, "is_entity": True, "label": ent.label_})
+    for chunk in spacy_doc.noun_chunks:
+         is_covered = any(ent_data["span"].start_char <= chunk.start_char and ent_data["span"].end_char >= chunk.end_char
+                          for ent_data in candidates if ent_data["is_entity"])
+         if not is_covered:
+             candidates.append({"span": chunk, "is_entity": False, "label": ""})
+    # 2. Adayları Filtrele, Normalleştir ve Kaydet
+    for data in candidates:
+        span = data["span"];
+        if span in processed_spans: continue
+        validated_text = normalize_and_validate_concept(span.text, data["is_entity"], data["label"])
+        if not validated_text: processed_spans.add(span); continue
+        concept_lemma = span.lemma_.lower().strip() if span.lemma_ else validated_text.lower()
+        is_concept = False
+        if data["is_entity"] and data["label"] in TRUSTED_ENTITY_LABELS: is_concept = True
+        elif NOUN_CHUNK_PATTERNS.match(validated_text): is_concept = True
+        elif any(keyword in concept_lemma.split() or keyword in validated_text.lower().split() for keyword in AI_KEYWORDS): is_concept = True
+        elif validated_text.isupper() and len(validated_text) > 1 and len(validated_text) < 6: is_concept = True
+        if is_concept:
+            concept_id = storage.add_concept(validated_text)
+            if concept_id:
+                mention_id = storage.add_mention(
+                    doc_id=doc_id, concept_id=concept_id,
+                    context=span.sent.text, start=span.start_char, end=span.end_char
+                )
+                if mention_id:
+                    mention_data = {
+                        "mention_id": mention_id, "concept_id": concept_id,
+                        "start_char": span.start_char, "end_char": span.end_char,
+                        "sentence": span.sent, "root_token": span.root
+                    }
+                    mentions_in_doc.append(mention_data); valid_mentions[mention_id] = mention_data
+        processed_spans.add(span)
+    # 3. İlişkileri Çıkar
+    for sentence in spacy_doc.sents:
+        mentions_in_sentence = [m for m in mentions_in_doc if m["sentence"] == sentence]
+        if len(mentions_in_sentence) >= 2:
+            for m1_data, m2_data in itertools.combinations(mentions_in_sentence, 2):
+                c1_id = m1_data["concept_id"]; c2_id = m2_data["concept_id"]
+                if c1_id == c2_id: continue
+                rel_pair = tuple(sorted((c1_id, c2_id)))
+                if rel_pair in added_relations: continue
+                relation_found = False
+                relation_info = find_verb_relation(m1_data["root_token"], m2_data["root_token"])
+                if relation_info:
+                    rel_type, verb = relation_info
+                    storage.add_relationship(
+                        source_concept_id=c1_id, target_concept_id=c2_id, rel_type=rel_type,
+                        mention_id=m1_data["mention_id"], doc_id=doc_id, sentence=sentence.text
+                    )
+                    relation_found = True; added_relations.add(rel_pair)
+                if not relation_found:
+                    storage.add_relationship(
+                        source_concept_id=c1_id, target_concept_id=c2_id, rel_type="RELATED_TO",
+                        mention_id=m1_data["mention_id"], doc_id=doc_id, sentence=sentence.text
+                    )
+                    added_relations.add(rel_pair)
+def process_documents_for_extraction():
+    """ Dokümanları işler ve durumu günceller... (Öncekiyle aynı) """
+    if not nlp: raise RuntimeError("spaCy modeli yüklenemedi.")
+    logging.info("Gelişmiş bilgi çıkarımı için dokümanlar işleniyor...")
+    documents_df = storage.load_dataframe('documents', storage.DOC_COLUMNS)
+    docs_to_process = documents_df[documents_df['status'] == 'added']
+    if docs_to_process.empty:
+        logging.info("Durumu 'added' olan ve işlenecek doküman bulunamadı.")
+        return
+    processed_count = 0; failed_count = 0
+    for index, doc_row in docs_to_process.iterrows():
+        doc_id = doc_row['doc_id']; filepath = Path(doc_row['filepath'])
+        logging.info(f"İşleniyor: {filepath.name} (ID: {doc_id})")
+        text = loaders.extract_text_from_pdf(filepath)
+        if text:
+            try:
+                extract_entities_and_relations(text, doc_id)
+                storage.update_document_status(doc_id, 'processed_v3') # Yeni versiyon durumu
+                processed_count += 1
+            except Exception as e:
+                logging.exception(f"'{filepath.name}' işlenirken BEKLENMEYEN HATA oluştu: {e}")
+                storage.update_document_status(doc_id, 'extraction_failed_v3')
+                failed_count += 1
+        else:
+            logging.warning(f"Metin çıkarılamadı: {filepath.name}")
+            storage.update_document_status(doc_id, 'text_extraction_failed')
+            failed_count += 1
+    logging.info(f"Gelişmiş bilgi çıkarımı tamamlandı. Başarılı: {processed_count}, Başarısız: {failed_count}")

loaders.py ADDED Viewed

	@@ -0,0 +1,136 @@

+import PyPDF2 # PDF dosyalarını okumak için
+from pathlib import Path
+from datetime import datetime
+import logging
+import re # Tarih ayrıştırma için Regular Expressions
+# Mevcut modüldeki storage fonksiyonlarını içe aktar (aynı klasörde olduğu için .)
+from .storage import add_document, load_dataframe, save_dataframe, DOC_COLUMNS
+# Ham veri klasörünün yolu
+RAW_DATA_PATH = Path("data/raw")
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+def extract_text_from_pdf(pdf_path: Path) -> str | None:
+    """
+    Verilen PDF dosyasının metin içeriğini çıkarır.
+    Args:
+        pdf_path (Path): PDF dosyasının yolu.
+    Returns:
+        str | None: Çıkarılan metin veya hata durumunda None.
+    """
+    try:
+        with open(pdf_path, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            text = ""
+            for page in reader.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + "\n" # Sayfalar arasına yeni satır ekle
+            logging.info(f"Metin çıkarıldı: {pdf_path.name}")
+            return text
+    except Exception as e:
+        logging.error(f"PDF metni çıkarılırken hata ({pdf_path.name}): {e}")
+        # Şifreli PDF'ler veya bozuk dosyalar PyPDF2 tarafından hata verebilir
+        if "password" in str(e).lower():
+             logging.warning(f"Dosya şifreli olabilir: {pdf_path.name}")
+        return None
+def parse_date_from_filename(filename: str) -> datetime | None:
+    """
+    Dosya adından YYYY-MM-DD veya YYYYMMDD formatında tarih ayrıştırmaya çalışır.
+    Args:
+        filename (str): Dosya adı.
+    Returns:
+        datetime | None: Bulunan tarih veya None.
+    """
+    # Örnek: 2023-10-26_paper.pdf, 20231026-paper.pdf, 2023_10_26 paper.pdf
+    patterns = [
+        r"(\d{4}-\d{2}-\d{2})", # YYYY-MM-DD
+        r"(\d{4}_\d{2}_\d{2})", # YYYY_MM_DD
+        r"(\d{8})"             # YYYYMMDD
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, filename)
+        if match:
+            date_str = match.group(1).replace("_", "-") # Alt çizgiyi tireye çevir
+            try:
+                # Sadece tarih kısmını al, saat bilgisi ekleme
+                return datetime.strptime(date_str, '%Y-%m-%d').date()
+            except ValueError:
+                continue # Geçersiz tarih formatı varsa diğer deseni dene
+    logging.warning(f"Dosya adından geçerli tarih ayrıştırılamadı: {filename}")
+    return None
+def process_raw_documents():
+    """
+    'data/raw/' klasöründeki tüm PDF dosyalarını işler,
+    tarihlerini ayrıştırır ve sisteme ekler (eğer zaten ekli değillerse).
+    """
+    if not RAW_DATA_PATH.exists():
+        logging.error(f"Ham veri klasörü bulunamadı: {RAW_DATA_PATH}")
+        return
+    logging.info(f"'{RAW_DATA_PATH}' klasöründeki PDF dosyaları işleniyor...")
+    processed_count = 0
+    added_count = 0
+    # Tüm PDF dosyalarını bul
+    pdf_files = list(RAW_DATA_PATH.glob('*.pdf'))
+    if not pdf_files:
+        logging.warning(f"'{RAW_DATA_PATH}' klasöründe işlenecek PDF dosyası bulunamadı.")
+        return
+    for pdf_path in pdf_files:
+        processed_count += 1
+        filename = pdf_path.name
+        filepath_str = str(pdf_path.resolve()) # Tam dosya yolunu al
+        # Dosya adından tarihi ayrıştır
+        publication_date = parse_date_from_filename(filename)
+        if publication_date:
+            # Dokümanı sisteme ekle (storage modülünü kullanarak)
+            # add_document, zaten varsa None yerine mevcut ID'yi döndürecek şekilde güncellendi
+            doc_id = add_document(filepath_str, publication_date)
+            if doc_id:
+                 # Eğer yeni eklendiyse (veya mevcut ID döndüyse), sayacı artırabiliriz
+                 # Şimdilik sadece eklenip eklenmediğini kontrol etmek yeterli
+                 # Gerçek ekleme 'add_document' içinde loglanıyor
+                 pass # Şimdilik ek bir işlem yapmıyoruz
+        else:
+            logging.warning(f"'{filename}' için yayın tarihi bulunamadı, doküman eklenemedi.")
+    logging.info(f"Toplam {processed_count} PDF dosyası tarandı.")
+    # Gerçekte kaç tane yeni eklendiği bilgisini storage loglarından takip edebiliriz.
+# --- Metin Çıkarma ve Kaydetme (Sonraki Fazlar İçin Hazırlık) ---
+# İleride bu fonksiyonu çağırıp metinleri ayrı dosyalara kaydedebiliriz
+# ve documents_df'i güncelleyebiliriz.
+#
+# def extract_and_save_text(doc_id: str, pdf_path: Path):
+#    text = extract_text_from_pdf(pdf_path)
+#    if text:
+#        # Metni kaydet (örn: data/processed_data/text/{doc_id}.txt)
+#        text_path = DATA_PATH / "text" / f"{doc_id}.txt"
+#        text_path.parent.mkdir(parents=True, exist_ok=True)
+#        try:
+#            with open(text_path, 'w', encoding='utf-8') as f:
+#                f.write(text)
+#            logging.info(f"Metin '{text_path}' olarak kaydedildi.")
+#            # documents_df'i güncelle (status='text_extracted', processed_text_path=str(text_path))
+#            docs_df = load_dataframe('documents', DOC_COLUMNS)
+#            doc_index = docs_df[docs_df['doc_id'] == doc_id].index
+#            if not doc_index.empty:
+#                docs_df.loc[doc_index, 'status'] = 'text_extracted'
+#                docs_df.loc[doc_index, 'processed_text_path'] = str(text_path)
+#                save_dataframe(docs_df, 'documents')
+#        except Exception as e:
+#            logging.error(f"Metin kaydedilirken hata ({doc_id}): {e}")

mentions.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:49749194f77092f6c3b9e6eacd4ef3a3c34f9d5d1f9c766a51123bdc57885c24
+size 9877

network_analysis.py ADDED Viewed

	@@ -0,0 +1,154 @@

+# src/analysis/network_analysis.py
+import networkx as nx
+import pandas as pd
+import logging
+# Topluluk tespiti için Louvain metodu (önce 'pip install python-louvain community' yapılmalı)
+try:
+    import community.community_louvain as community_louvain
+    community_lib_available = True
+except ImportError:
+    logging.warning("'community' (python-louvain) kütüphanesi bulunamadı. Topluluk tespiti yapılamayacak. Kurulum için: pip install python-louvain community")
+    community_lib_available = False
+# Yerel modüller
+from src.data_management import storage
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+def calculate_centrality(graph: nx.Graph) -> dict:
+    """
+    Graf üzerindeki düğümler için merkeziyet metriklerini hesaplar.
+    Args:
+        graph (nx.Graph): Analiz edilecek NetworkX grafı.
+    Returns:
+        dict: {node_id: {'degree': float, 'betweenness': float, 'eigenvector': float (veya None)}}
+              formatında metrikleri içeren sözlük.
+    """
+    metrics = {}
+    if not graph or graph.number_of_nodes() == 0:
+        return metrics
+    try:
+        degree_centrality = nx.degree_centrality(graph)
+    except Exception as e:
+        logging.error(f"Degree Centrality hesaplanırken hata: {e}")
+        degree_centrality = {}
+    try:
+        betweenness_centrality = nx.betweenness_centrality(graph)
+    except Exception as e:
+        logging.error(f"Betweenness Centrality hesaplanırken hata: {e}")
+        betweenness_centrality = {}
+    try:
+        # Eigenvector centrality bağlantısız (disconnected) graflarda veya bazı durumlarda hata verebilir
+        # max_iter artırılabilir veya hata yakalanabilir
+        eigenvector_centrality = nx.eigenvector_centrality(graph, max_iter=500, tol=1e-06)
+    except Exception as e:
+        logging.warning(f"Eigenvector Centrality hesaplanırken hata (graf bağlantısız olabilir): {e}")
+        eigenvector_centrality = {} # Hata durumunda boş bırak
+    # Metrikleri birleştir
+    for node in graph.nodes():
+        metrics[node] = {
+            'degree_centrality': degree_centrality.get(node, 0.0),
+            'betweenness_centrality': betweenness_centrality.get(node, 0.0),
+            'eigenvector_centrality': eigenvector_centrality.get(node, None) # Hata durumunda None olabilir
+        }
+    logging.info("Merkeziyet metrikleri hesaplandı.")
+    return metrics
+def detect_communities(graph: nx.Graph) -> dict | None:
+    """
+    Louvain algoritması kullanarak graf üzerindeki toplulukları tespit eder.
+    Args:
+        graph (nx.Graph): Analiz edilecek NetworkX grafı.
+    Returns:
+        dict | None: {node_id: community_id} formatında bölümleme sözlüğü veya hata/kütüphane yoksa None.
+    """
+    if not community_lib_available:
+        return None # Kütüphane yoksa hesaplama yapma
+    if not graph or graph.number_of_nodes() == 0:
+        return None # Boş graf
+    # Louvain metodu yönlendirilmemiş graflarda daha iyi çalışır.
+    # Eğer graf yönlü ise, yönlendirilmemişe çevir (veya uyarı ver).
+    # Bizim grafımız zaten yönlendirilmemiş (nx.Graph).
+    # Ağırlıklı kenarları kullanabilir (varsayılan weight='weight')
+    try:
+        partition = community_louvain.best_partition(graph, weight='weight') # Kenar ağırlıklarını dikkate al
+        num_communities = len(set(partition.values()))
+        logging.info(f"Louvain ile topluluk tespiti tamamlandı. {num_communities} topluluk bulundu.")
+        return partition
+    except Exception as e:
+        logging.exception(f"Topluluk tespiti sırasında hata oluştu: {e}")
+        return None
+def get_network_analysis_results(graph: nx.Graph) -> pd.DataFrame | None:
+    """
+    Merkeziyet ve topluluk analizlerini yapar ve sonuçları bir DataFrame'de birleştirir.
+    Args:
+        graph (nx.Graph): Analiz edilecek NetworkX grafı.
+    Returns:
+        pd.DataFrame | None: 'concept_id', 'name', 'degree_centrality', 'betweenness_centrality',
+                             'eigenvector_centrality', 'community_id' sütunlarını içeren DataFrame
+                             veya hata durumunda None.
+    """
+    if not graph or graph.number_of_nodes() == 0:
+        logging.warning("Analiz için boş veya geçersiz graf sağlandı.")
+        return None
+    logging.info("Ağ analizi metrikleri hesaplanıyor...")
+    centrality_metrics = calculate_centrality(graph)
+    community_partition = detect_communities(graph)
+    # Sonuçları bir DataFrame'e dönüştür
+    analysis_data = []
+    concepts_df = storage.load_dataframe('concepts', storage.CONCEPT_COLUMNS) # İsimler için yükle
+    for node_id, metrics in centrality_metrics.items():
+        node_data = {
+            'concept_id': node_id,
+            'name': graph.nodes[node_id].get('name', 'N/A'), # Graf düğümünden al
+            'degree_centrality': metrics.get('degree_centrality'),
+            'betweenness_centrality': metrics.get('betweenness_centrality'),
+            'eigenvector_centrality': metrics.get('eigenvector_centrality'),
+            'community_id': community_partition.get(node_id, -1) if community_partition else -1 # Topluluk yoksa -1
+        }
+        analysis_data.append(node_data)
+    if not analysis_data:
+        logging.warning("Ağ analizi sonucu veri üretilemedi.")
+        return None
+    analysis_df = pd.DataFrame(analysis_data)
+    # Eğer graf düğümlerinde isim yoksa, concepts_df'ten almayı dene (yedek)
+    if 'N/A' in analysis_df['name'].values and concepts_df is not None:
+         analysis_df = analysis_df.drop(columns=['name']) # Eski 'name' sütununu sil
+         analysis_df = pd.merge(analysis_df, concepts_df[['concept_id', 'name']], on='concept_id', how='left')
+         # Sütun sırasını ayarla
+         cols = ['concept_id', 'name'] + [col for col in analysis_df.columns if col not in ['concept_id', 'name']]
+         analysis_df = analysis_df[cols]
+    logging.info("Ağ analizi sonuçları DataFrame'e dönüştürüldü.")
+    return analysis_df
+def save_network_analysis(analysis_df: pd.DataFrame):
+    """ Ağ analizi sonuçlarını Parquet dosyasına kaydeder. """
+    if analysis_df is not None and not analysis_df.empty:
+        storage.save_dataframe(analysis_df, storage.NETWORK_ANALYSIS_FILENAME)
+        logging.info(f"Ağ analizi sonuçları '{storage.NETWORK_ANALYSIS_FILENAME}.parquet' olarak kaydedildi.")
+    else:
+        logging.warning("Kaydedilecek ağ analizi sonucu bulunamadı.")

network_builder.py ADDED Viewed

	@@ -0,0 +1,118 @@

+# src/analysis/network_builder.py (DÜZELTİLMİŞ TAM KOD)
+import networkx as nx
+import pandas as pd
+import logging
+# Yerel modüller
+from src.data_management import storage
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Grafı kaydetmek için dosya adı
+GRAPH_FILENAME = "concept_network"
+# Benzerlik dosyasının adı (Doğrudan burada tanımlayalım veya similarity'den import edelim)
+# storage modülünde değil!
+SIMILARITY_FILENAME = "concept_similarities"
+def build_concept_network(similarity_threshold: float = 0.60,
+                            include_similarity_edges: bool = True,
+                            include_extracted_edges: bool = True) -> nx.Graph | None:
+    """
+    Konseptler, çıkarılmış ilişkiler ve anlamsal benzerliklerden bir NetworkX grafı oluşturur.
+    Args:
+        similarity_threshold (float): Grafiğe eklenecek minimum anlamsal benzerlik skoru.
+        include_similarity_edges (bool): Benzerlik kenarlarını dahil et.
+        include_extracted_edges (bool): Metinden çıkarılan ilişki kenarlarını dahil et.
+    Returns:
+        nx.Graph | None: Oluşturulan NetworkX grafı veya hata durumunda None.
+    """
+    logging.info("Konsept ağı oluşturuluyor...")
+    if not include_similarity_edges and not include_extracted_edges:
+        logging.warning("Hem benzerlik hem de çıkarılmış ilişki kenarları devre dışı bırakıldı.")
+    # Temel verileri yükle
+    concepts_df = storage.load_dataframe('concepts', storage.CONCEPT_COLUMNS)
+    relationships_df = storage.load_dataframe('relationships', storage.RELATIONSHIP_COLUMNS)
+    # *** DÜZELTME: SIMILARITY_FILENAME doğrudan kullanılıyor ***
+    similarity_df = storage.load_dataframe(SIMILARITY_FILENAME, ['concept_id_1', 'concept_id_2', 'similarity'])
+    if concepts_df is None or concepts_df.empty:
+        logging.error("Ağ oluşturmak için konsept verisi bulunamadı.")
+        return None
+    G = nx.Graph()
+    # 1. Adım: Konseptleri Düğüm Olarak Ekle
+    node_count = 0
+    valid_concept_ids = set() # Grafiğe eklenen geçerli ID'leri takip et
+    for index, row in concepts_df.iterrows():
+        concept_id = row['concept_id']
+        concept_name = row['name']
+        if pd.notna(concept_id) and pd.notna(concept_name):
+             G.add_node(concept_id, name=concept_name)
+             valid_concept_ids.add(concept_id)
+             node_count += 1
+        else:
+             logging.warning(f"Geçersiz konsept verisi atlandı: ID={concept_id}, Name={concept_name}")
+    logging.info(f"{node_count} konsept düğüm olarak eklendi.")
+    edge_count_extracted = 0
+    edge_count_similarity = 0
+    updated_edge_count = 0
+    # 2. Adım: Çıkarılmış İlişkileri Kenar Olarak Ekle
+    if include_extracted_edges and relationships_df is not None and not relationships_df.empty:
+        logging.info("Çıkarılmış ilişkiler kenar olarak ekleniyor...")
+        for index, row in relationships_df.iterrows():
+            source_id = row['source_concept_id']
+            target_id = row['target_concept_id']
+            rel_type = row['type'] or 'RELATED_TO'
+            # Düğümlerin grafide olduğundan ve geçerli olduğundan emin ol
+            if source_id in valid_concept_ids and target_id in valid_concept_ids:
+                if G.has_edge(source_id, target_id):
+                     G.edges[source_id, target_id]['relation_type'] = rel_type
+                     G.edges[source_id, target_id]['type'] = 'extracted'
+                else:
+                     G.add_edge(source_id, target_id, type='extracted', relation_type=rel_type, weight=0.8)
+                     edge_count_extracted += 1
+            else:
+                 logging.warning(f"İlişki için düğüm(ler) bulunamadı veya geçersiz: {source_id} -> {target_id}")
+        logging.info(f"{edge_count_extracted} çıkarılmış ilişki kenarı eklendi.")
+    # 3. Adım: Anlamsal Benzerlikleri Kenar Olarak Ekle
+    if include_similarity_edges and similarity_df is not None and not similarity_df.empty:
+        logging.info(f"Anlamsal benzerlikler (Eşik > {similarity_threshold:.2f}) kenar olarak ekleniyor...")
+        filtered_similarity = similarity_df[(similarity_df['similarity'] >= similarity_threshold) & (similarity_df['similarity'] < 1.0)]
+        logging.info(f"{len(similarity_df)} benzerlik çiftinden {len(filtered_similarity)} tanesi eşik değerinin üzerinde (ve < 1.0).")
+        for index, row in filtered_similarity.iterrows():
+            id1 = row['concept_id_1']
+            id2 = row['concept_id_2']
+            similarity = row['similarity']
+            if id1 in valid_concept_ids and id2 in valid_concept_ids:
+                if G.has_edge(id1, id2):
+                     G.edges[id1, id2]['similarity'] = similarity
+                     if 'weight' not in G.edges[id1, id2] or similarity > G.edges[id1, id2].get('weight', 0):
+                          G.edges[id1, id2]['weight'] = similarity
+                     # Eğer extracted ilişki varsa, tipi 'combined' yapabiliriz?
+                     G.edges[id1, id2]['type'] = 'combined' if G.edges[id1, id2].get('type') == 'extracted' else G.edges[id1, id2].get('type', 'similarity') # Önceliği koru veya birleştir
+                     updated_edge_count += 1
+                else:
+                     G.add_edge(id1, id2, type='similarity', weight=similarity)
+                     edge_count_similarity += 1
+            else:
+                logging.warning(f"Benzerlik için düğüm(ler) bulunamadı veya geçersiz: {id1} <-> {id2}")
+        logging.info(f"{edge_count_similarity} yeni benzerlik kenarı eklendi, {updated_edge_count} mevcut kenara benzerlik/tip bilgisi eklendi.")
+    total_edges = G.number_of_edges()
+    logging.info(f"Konsept ağı oluşturuldu. Düğüm sayısı: {G.number_of_nodes()}, Kenar sayısı: {total_edges}.")
+    # 4. Adım: Grafı Kaydet
+    storage.save_network(G, GRAPH_FILENAME)
+    return G

plotting.py ADDED Viewed

	@@ -0,0 +1,155 @@

+# src/visualization/plotting.py (Ağ Metrikleri ile Görselleştirme Güncellendi)
+import networkx as nx
+from pyvis.network import Network
+import logging
+from pathlib import Path
+import pandas as pd
+import random # Renk paleti için
+# Yerel modüller
+from src.data_management import storage
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Görselleştirme dosyalarının kaydedileceği yer
+OUTPUT_DIR = Path("output/graphs")
+DEFAULT_GRAPH_FILENAME = "concept_network"
+# Analiz sonuçları dosyasının adı (storage'dan da alınabilirdi)
+DEFAULT_ANALYSIS_FILENAME = storage.NETWORK_ANALYSIS_FILENAME
+# Basit bir renk paleti (daha fazla renk eklenebilir veya matplotlib colormap kullanılabilir)
+# Viridis, tab10, Set3 gibi paletler iyi çalışır
+# Örnek: import matplotlib.cm as cm; colors = [cm.tab10(i) for i in range(10)]
+DEFAULT_COLORS = [
+    "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
+    "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"
+]
+def get_color_for_community(community_id, colors=DEFAULT_COLORS):
+    """ Verilen community ID için paletten bir renk döndürür. """
+    if community_id < 0 or community_id is None or pd.isna(community_id): # Topluluk yoksa veya geçersizse
+        return "#CCCCCC" # Gri
+    return colors[int(community_id) % len(colors)] # Modulo ile renk tekrarı
+def scale_value(value, min_val=0, max_val=1, new_min=10, new_max=50):
+    """ Bir değeri belirli bir aralığa ölçekler (örn: merkeziyet -> düğüm boyutu). """
+    if max_val == min_val or value is None or pd.isna(value): # Bölme hatasını veya None değerini engelle
+        return new_min # Veya ortalama bir değer?
+    # Ölçekleme: (value - min) / (max - min) * (new_max - new_min) + new_min
+    scaled = ((value - min_val) / (max_val - min_val)) * (new_max - new_min) + new_min
+    return max(new_min, min(scaled, new_max)) # Sonuçların min/max arasında kalmasını sağla
+def visualize_network(graph: nx.Graph | None = None,
+                      graph_filename: str = DEFAULT_GRAPH_FILENAME,
+                      analysis_filename: str = DEFAULT_ANALYSIS_FILENAME,
+                      output_filename: str = "concept_network_visualization.html",
+                      show_buttons: bool = True,
+                      physics_solver: str = 'barnesHut',
+                      size_metric: str = 'degree_centrality', # Boyut için kullanılacak metrik
+                      color_metric: str = 'community_id',    # Renk için kullanılacak metrik
+                      height: str = "800px",
+                      width: str = "100%"
+                     ) -> str | None:
+    """
+    Ağ grafını Pyvis ile görselleştirir. Düğüm boyutu ve rengi için ağ
+    analizi metriklerini kullanır.
+    """
+    if graph is None:
+        logging.info(f"Graf sağlanmadı, '{graph_filename}.pkl' dosyasından yükleniyor...")
+        graph = storage.load_network(graph_filename)
+    if graph is None or not isinstance(graph, nx.Graph) or graph.number_of_nodes() == 0:
+        logging.error("Görselleştirilecek geçerli veya boş olmayan bir graf bulunamadı.")
+        return None
+    # Ağ analizi sonuçlarını yükle
+    logging.info(f"Ağ analizi sonuçları '{analysis_filename}.parquet' dosyasından yükleniyor...")
+    analysis_df = storage.load_dataframe(analysis_filename, []) # Sütunları bilmediğimiz için boş liste
+    metrics_dict = {}
+    min_size_val, max_size_val = 0, 1 # Boyut ölçekleme için min/max
+    if analysis_df is not None and not analysis_df.empty and 'concept_id' in analysis_df.columns:
+        # Eksik metrik sütunlarını kontrol et ve ekle (NaN ile)
+        required_metrics = [size_metric, color_metric]
+        for metric in required_metrics:
+            if metric not in analysis_df.columns:
+                 logging.warning(f"Analiz sonuçlarında '{metric}' sütunu bulunamadı. Varsayılan değerler kullanılacak.")
+                 analysis_df[metric] = None
+        # Boyut metriği için min/max değerleri bul (NaN olmayanlardan)
+        if size_metric in analysis_df.columns and analysis_df[size_metric].notna().any():
+            min_size_val = analysis_df[size_metric].min()
+            max_size_val = analysis_df[size_metric].max()
+        # Kolay erişim için sözlüğe çevir
+        metrics_dict = analysis_df.set_index('concept_id').to_dict('index')
+        logging.info("Ağ analizi metrikleri yüklendi.")
+    else:
+        logging.warning("Ağ analizi sonuçları yüklenemedi veya boş. Varsayılan düğüm boyutları/renkleri kullanılacak.")
+    logging.info(f"'{output_filename}' için Pyvis ağı oluşturuluyor...")
+    net = Network(notebook=False, height=height, width=width, heading='ChronoSense Konsept Ağı (Metriklerle)', cdn_resources='remote')
+    net.barnes_hut(gravity=-8000, central_gravity=0.1, spring_length=150, spring_strength=0.005, damping=0.09)
+    # Düğümleri (Nodes) Pyvis'e ekle (Boyut ve Renk ile)
+    for node, attrs in graph.nodes(data=True):
+        node_label = attrs.get('name', str(node))
+        node_metrics = metrics_dict.get(node, {}) # Bu düğüm için metrikleri al, yoksa boş dict
+        # Boyutu hesapla
+        size_val = node_metrics.get(size_metric)
+        node_size = scale_value(size_val, min_size_val, max_size_val, new_min=10, new_max=40) # 10-40 arası boyut
+        # Rengi hesapla
+        color_val = node_metrics.get(color_metric)
+        node_color = get_color_for_community(color_val)
+        # Başlığı (Title) güncelle (metrikleri ekle)
+        node_title = f"ID: {node}<br>Name: {attrs.get('name', 'N/A')}"
+        node_title += f"<br>{size_metric}: {size_val:.3f}" if pd.notna(size_val) else ""
+        node_title += f"<br>{color_metric}: {int(color_val)}" if pd.notna(color_val) else ""
+        net.add_node(node, label=node_label, title=node_title, size=node_size, color=node_color)
+    # Kenarları (Edges) Pyvis'e ekle (Öncekiyle aynı, sadece renk/kalınlık ayarları biraz daha belirgin)
+    for source, target, attrs in graph.edges(data=True):
+        edge_title = f"Type: {attrs.get('type', 'N/A')}"
+        edge_value = 0.5 ; edge_color = "#DDDDDD" # Daha soluk varsayılan
+        edge_type = attrs.get('type')
+        weight = attrs.get('weight', 0)
+        if edge_type == 'extracted':
+             edge_title += f"<br>Relation: {attrs.get('relation_type', 'N/A')}"
+             edge_value = max(0.6, weight) # extracted ilişkiler biraz daha belirgin olsun
+             edge_color = "#FF6347" # Koyu turuncu/kırmızımsı
+        elif edge_type == 'similarity':
+             sim_score = attrs.get('similarity', weight)
+             edge_title += f"<br>Similarity: {sim_score:.3f}"
+             edge_value = sim_score # Benzerlikle orantılı
+             edge_color = "#4682B4" # Çelik mavisi
+        elif edge_type == 'combined':
+             edge_title += f"<br>Relation: {attrs.get('relation_type', 'N/A')}"
+             sim_score = attrs.get('similarity', weight)
+             edge_title += f"<br>Similarity: {sim_score:.3f}"
+             edge_value = max(0.6, sim_score) # Combined da belirgin olsun
+             edge_color = "#9370DB" # Orta mor
+        net.add_edge(source, target, title=edge_title, value=max(0.1, edge_value), color=edge_color)
+    if show_buttons:
+        net.show_buttons(filter_=['physics', 'nodes', 'edges'])
+    try:
+        OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+        output_path = OUTPUT_DIR / output_filename
+        net.save_graph(str(output_path))
+        logging.info(f"Ağ görselleştirmesi başarıyla '{output_path}' olarak kaydedildi.")
+        return str(output_path)
+    except Exception as e:
+        logging.exception(f"Ağ görselleştirmesi kaydedilirken hata oluştu: {e}")
+        return None

relationships.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:a41341ec01d3c46cd036ac155cc8ea50d773221f34ab578f067bc21d7581f5fe
+size 10289

requirements.txt ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ pip install pandas numpy spacy scikit-learn networkx matplotlib plotly pyvis streamlit PyPDF2 sentence-transformers pytest pyarrow
2	+ python -m spacy download en_core_web_lg

reset_status.py ADDED Viewed

	@@ -0,0 +1,24 @@

+# reset_status.py
+import pandas as pd
+# storage modülünü doğru import etmek için src'yi sys.path'e ekleyebilir veya PYTHONPATH ayarlayabiliriz.
+# En kolayı çalıştırmadan önce PYTHONPATH ayarlamak veya geçici olarak sys.path'e eklemek.
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent))
+from src.data_management.storage import load_dataframe, save_dataframe, DOC_COLUMNS
+print("Doküman durumları 'added' olarak sıfırlanıyor...")
+df = load_dataframe('documents', DOC_COLUMNS)
+if not df.empty:
+    # Sadece işlenmiş veya hata almış olanları sıfırla
+    reset_mask = df['status'].str.startswith('processed', na=False) | df['status'].str.contains('failed', na=False)
+    if reset_mask.any():
+        df.loc[reset_mask, 'status'] = 'added'
+        save_dataframe(df, 'documents')
+        print(f"{reset_mask.sum()} dokümanın durumu 'added' olarak sıfırlandı.")
+    else:
+        print("Durumu sıfırlanacak doküman bulunamadı ('processed' veya 'failed' durumunda olan).")
+else:
+    print("Doküman DataFrame'i bulunamadı veya boş.")

run_analysis.py ADDED Viewed

	@@ -0,0 +1,125 @@

+# run_analysis.py (Ağ Analizi Metrikleri Eklendi)
+import time
+import pandas as pd
+import sys
+from pathlib import Path
+import networkx as nx
+import webbrowser
+import logging
+# src klasöründeki modüllere erişim için
+sys.path.insert(0, str(Path(__file__).parent))
+from src.analysis.temporal import calculate_concept_frequencies
+from src.analysis.similarity import calculate_concept_embeddings, calculate_similarity_matrix
+from src.analysis.network_builder import build_concept_network
+# YENİ importlar:
+from src.analysis.network_analysis import get_network_analysis_results, save_network_analysis
+from src.visualization.plotting import visualize_network
+from src.data_management.storage import load_dataframe, save_dataframe, CONCEPT_COLUMNS, FREQUENCY_FILENAME, SIMILARITY_FILENAME, NETWORK_ANALYSIS_FILENAME # YENİ: NETWORK_ANALYSIS_FILENAME
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+pd.set_option('display.max_rows', 100)
+pd.set_option('display.max_columns', 10)
+pd.set_option('display.width', 1000)
+if __name__ == "__main__":
+    print(">>> Analizler Çalıştırılıyor (Frekans + Benzerlik + Ağ + Metrikler + Görselleştirme) <<<")
+    overall_start_time = time.time()
+    concepts_df = None
+    frequency_results_df = None
+    similarity_results_df = None
+    concept_network = None # Grafı saklamak için
+    network_analysis_df = None # Analiz sonuçlarını saklamak için
+    # --- 1. Frekans Analizi ---
+    print("\n--- 1. Frekans Hesaplaması ---"); start_time = time.time()
+    # ... (önceki kodla aynı, sadece print süresi değişebilir) ...
+    frequency_df = calculate_concept_frequencies(time_period='YS')
+    if frequency_df is not None:
+        concepts_df = load_dataframe('concepts', CONCEPT_COLUMNS)
+        if not frequency_df.empty:
+             print(f"Toplam {len(frequency_df)} frekans kaydı hesaplandı.")
+             if concepts_df is not None and not concepts_df.empty:
+                 frequency_results_df = pd.merge(frequency_df, concepts_df[['concept_id', 'name']], on='concept_id', how='left')
+                 frequency_results_df = frequency_results_df[['concept_id', 'name', 'time_period_start', 'frequency']]
+                 frequency_results_df.sort_values(by=['name', 'time_period_start'], inplace=True)
+                 print("\n--- Konsept Frekansları (Yıllık) ---"); print(frequency_results_df.to_string())
+                 save_dataframe(frequency_results_df, FREQUENCY_FILENAME)
+             else: print("\nKonsept isimleri yüklenemedi..."); print(frequency_df.to_string())
+        else: print("Frekans hesaplandı ancak sonuç boş."); save_dataframe(pd.DataFrame(columns=['concept_id', 'name', 'time_period_start', 'frequency']), FREQUENCY_FILENAME)
+    else: print("Frekans hesaplaması sırasında bir hata oluştu.")
+    print(f"--- Frekans Hesaplaması Tamamlandı. Süre: {time.time() - start_time:.2f} saniye ---")
+    # --- 2. Anlamsal Benzerlik Analizi ---
+    print("\n--- 2. Anlamsal Benzerlik Hesaplaması ---"); start_time = time.time()
+    # ... (önceki kodla aynı, sadece print süresi değişebilir) ...
+    try:
+        concept_embeddings = calculate_concept_embeddings(force_recalculate=False)
+        if concept_embeddings:
+            similarity_df = calculate_similarity_matrix(concept_embeddings, force_recalculate=False)
+            if similarity_df is not None and not similarity_df.empty:
+                print(f"Toplam {len(similarity_df)} konsept çifti için benzerlik hesaplandı/yüklendi.")
+                if concepts_df is None or concepts_df.empty: concepts_df = load_dataframe('concepts', CONCEPT_COLUMNS)
+                if concepts_df is not None and not concepts_df.empty:
+                    sim_results = pd.merge(similarity_df, concepts_df[['concept_id', 'name']], left_on='concept_id_1', right_on='concept_id', how='left').rename(columns={'name': 'name_1'}).drop(columns=['concept_id'])
+                    sim_results = pd.merge(sim_results, concepts_df[['concept_id', 'name']], left_on='concept_id_2', right_on='concept_id', how='left').rename(columns={'name': 'name_2'}).drop(columns=['concept_id'])
+                    sim_results = sim_results[['concept_id_1', 'name_1', 'concept_id_2', 'name_2', 'similarity']]
+                    sim_results.sort_values(by='similarity', ascending=False, inplace=True)
+                    similarity_results_df = sim_results
+                    print("\n--- En Benzer Konsept Çiftleri (Top 20) ---"); print(similarity_results_df.head(20).to_string(index=False))
+                    save_dataframe(similarity_results_df, SIMILARITY_FILENAME)
+                else: print("\nKonsept isimleri yüklenemedi..."); print(similarity_df.sort_values(by='similarity', ascending=False).head(20).to_string(index=False))
+            elif similarity_df is not None: print("Benzerlik hesaplandı ancak sonuç boş."); save_dataframe(pd.DataFrame(columns=['concept_id_1', 'name_1', 'concept_id_2', 'name_2', 'similarity']), SIMILARITY_FILENAME)
+    except Exception as e: logging.exception("Benzerlik hesaplama sırasında beklenmedik hata oluştu.")
+    print(f"--- Benzerlik Hesaplaması Tamamlandı. Süre: {time.time() - start_time:.2f} saniye ---")
+    # --- 3. Ağ Oluşturma ---
+    print("\n--- 3. Konsept Ağı Oluşturma ---"); start_time = time.time()
+    # GÜNCELLEME: Ağ nesnesini değişkende tut
+    concept_network = build_concept_network(similarity_threshold=0.60)
+    if concept_network is not None:
+        print("\n--- Oluşturulan Ağ Bilgileri ---")
+        print(f"Düğüm Sayısı (Konseptler): {concept_network.number_of_nodes()}")
+        print(f"Kenar Sayısı (İlişkiler/Benzerlikler): {concept_network.number_of_edges()}")
+        print(f"Ağ başarıyla oluşturuldu ve kaydedildi.")
+    else:
+        print("Konsept ağı oluşturulamadı.")
+    print(f"--- Ağ Oluşturma Tamamlandı. Süre: {time.time() - start_time:.2f} saniye ---")
+    # --- YENİ: 4. Ağ Analizi (Metrik Hesaplama) ---
+    print("\n--- 4. Ağ Analizi Metrikleri ---"); start_time = time.time()
+    if concept_network is not None and concept_network.number_of_nodes() > 0:
+        network_analysis_df = get_network_analysis_results(concept_network)
+        if network_analysis_df is not None and not network_analysis_df.empty:
+             # Sonuçları kaydet
+             save_network_analysis(network_analysis_df)
+             print("Ağ metrikleri hesaplandı ve kaydedildi.")
+             # En yüksek derece merkeziyetine sahip ilk 10 konsepti göster
+             print("\n--- En Merkezi Konseptler (Degree Centrality Top 10) ---")
+             print(network_analysis_df.sort_values(by='degree_centrality', ascending=False).head(10).to_string(index=False))
+        else:
+             print("Ağ metrikleri hesaplanamadı veya sonuç boş.")
+    else:
+        print("Ağ analizi yapmak için geçerli bir ağ bulunamadı.")
+    print(f"--- Ağ Analizi Tamamlandı. Süre: {time.time() - start_time:.2f} saniye ---")
+    # --- YENİ SIRA: 5. Ağ Görselleştirme ---
+    print("\n--- 5. Ağ Görselleştirmesi Oluşturma ---"); start_time = time.time()
+    visualization_path = None
+    if concept_network is not None:
+        # GÜNCELLEME: Analiz sonuçlarını da görselleştirmeye gönderebiliriz (ileride plotting.py'ı güncelleyince)
+        # Şimdilik sadece grafı gönderiyoruz.
+        visualization_path = visualize_network(graph=concept_network, output_filename="concept_network_visualization.html")
+        if visualization_path:
+            print(f"\nBaşarılı! İnteraktif ağ görselleştirmesi oluşturuldu:\n-> {visualization_path}")
+            print("\nBu HTML dosyasını web tarayıcınızda açarak ağı inceleyebilirsiniz.")
+        else: print("Ağ görselleştirmesi oluşturulurken bir sorun oluştu.")
+    else: print("Ağ oluşturulamadığı için görselleştirme yapılamıyor.")
+    print(f"--- Ağ Görselleştirme Tamamlandı. Süre: {time.time() - start_time:.2f} saniye ---")
+    overall_end_time = time.time()
+    print(f"\n<<< Tüm İşlemler Tamamlandı. Toplam Süre: {overall_end_time - overall_start_time:.2f} saniye >>>")

run_extractor.py ADDED Viewed

	@@ -0,0 +1,15 @@

+import time
+# src klasöründeki modüllerimize erişmek için
+from src.extraction.extractor import process_documents_for_extraction
+if __name__ == "__main__":
+    print(">>> Bilgi çıkarıcı çalıştırılıyor...")
+    print("Not: Bu işlem dokümanların uzunluğuna ve sayısına göre biraz zaman alabilir.")
+    start_time = time.time()
+    # Ana çıkarım fonksiyonumuzu çağırıyoruz
+    process_documents_for_extraction()
+    end_time = time.time()
+    print(f"<<< Bilgi çıkarıcı tamamlandı. Süre: {end_time - start_time:.2f} saniye.")
+    print(f"Kontrol edilmesi gereken dosyalar: data/processed_data/ klasöründeki concepts.parquet, mentions.parquet, relationships.parquet ve güncellenmiş documents.parquet")

run_loader.py ADDED Viewed

	@@ -0,0 +1,14 @@

+import time
+# src klasöründeki modüllerimize erişmek için
+from src.data_management.loaders import process_raw_documents
+if __name__ == "__main__":
+    print(">>> Veri yükleyici çalıştırılıyor...")
+    start_time = time.time()
+    # Ana işlem fonksiyonumuzu çağırıyoruz
+    process_raw_documents()
+    end_time = time.time()
+    print(f"<<< Veri yükleyici tamamlandı. Süre: {end_time - start_time:.2f} saniye.")
+    print(f"Kontrol edilmesi gereken dosya: data/processed_data/documents.parquet")

similarity.py ADDED Viewed

	@@ -0,0 +1,170 @@

+# src/analysis/similarity.py
+import pandas as pd
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import logging
+from pathlib import Path
+# Yerel modüller
+from src.data_management import storage
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Benzerlik matrisini kaydetmek için dosya adı
+SIMILARITY_FILENAME = "concept_similarities"
+EMBEDDINGS_FILENAME = "concept_embeddings" # Vektörleri de kaydedebiliriz
+def calculate_concept_embeddings(model_name: str = 'all-MiniLM-L6-v2', force_recalculate: bool = False) -> dict[str, np.ndarray] | None:
+    """
+    Her konsept için ortalama embedding vektörünü hesaplar.
+    Mention'ların context_snippet'lerini kullanır.
+    Hesaplanmış embedding'leri yüklemeye çalışır, yoksa hesaplar.
+    Args:
+        model_name (str): Kullanılacak Sentence Transformer modeli.
+        force_recalculate (bool): Daha önce hesaplanmış olsa bile yeniden hesaplamaya zorla.
+    Returns:
+        dict[str, np.ndarray] | None: Concept ID -> Ortalama Embedding Vektörü sözlüğü veya hata durumunda None.
+    """
+    embeddings_filepath = storage.DATA_PATH / f"{EMBEDDINGS_FILENAME}.pkl" # Pickle ile saklayalım
+    if not force_recalculate and embeddings_filepath.exists():
+        try:
+            embeddings = pd.read_pickle(embeddings_filepath)
+            logging.info(f"Önceden hesaplanmış embedding'ler '{embeddings_filepath}' dosyasından yüklendi.")
+            # Dosyadan yüklenen bir sözlük olmalı
+            if isinstance(embeddings, dict):
+                 return embeddings
+            else:
+                 logging.warning("Yüklenen embedding dosyası beklenen formatta (dict) değil. Yeniden hesaplanacak.")
+        except Exception as e:
+            logging.error(f"Embedding'ler yüklenirken hata: {e}. Yeniden hesaplanacak.")
+    logging.info("Konsept embedding'leri hesaplanıyor...")
+    mentions_df = storage.load_dataframe('mentions', storage.MENTION_COLUMNS)
+    if mentions_df is None or mentions_df.empty:
+        logging.warning("Hesaplama için mention verisi bulunamadı.")
+        return None
+    # Geçerli context snippet'i olan mention'ları al
+    mentions_df.dropna(subset=['context_snippet', 'concept_id'], inplace=True)
+    if mentions_df.empty:
+        logging.warning("Geçerli context snippet bulunamadı.")
+        return None
+    # Modeli yükle (ilk seferde internetten indirilebilir)
+    try:
+        model = SentenceTransformer(model_name)
+        logging.info(f"Sentence Transformer modeli '{model_name}' yüklendi.")
+    except Exception as e:
+        logging.exception(f"Sentence Transformer modeli '{model_name}' yüklenirken hata: {e}")
+        return None
+    # Konseptlere göre grupla
+    grouped_mentions = mentions_df.groupby('concept_id')['context_snippet'].apply(list)
+    concept_embeddings = {}
+    logging.info(f"{len(grouped_mentions)} konsept için embedding hesaplanacak...")
+    # Her konsept için embedding'leri hesapla ve ortalamasını al
+    for concept_id, snippets in grouped_mentions.items():
+        if not snippets: continue # Boş snippet listesi varsa atla
+        try:
+            # Tüm snippet'ların embedding'lerini tek seferde hesapla (daha verimli)
+            embeddings = model.encode(snippets, show_progress_bar=False) # İlerleme çubuğunu kapat
+            # Ortalama embedding'i hesapla
+            avg_embedding = np.mean(embeddings, axis=0)
+            concept_embeddings[concept_id] = avg_embedding
+        except Exception as e:
+            logging.error(f"Concept ID {concept_id} için embedding hesaplanırken hata: {e}")
+            continue # Bu konsepti atla
+    # Hesaplanan embedding'leri kaydet
+    try:
+        storage.DATA_PATH.mkdir(parents=True, exist_ok=True)
+        pd.to_pickle(concept_embeddings, embeddings_filepath)
+        logging.info(f"Hesaplanan embedding'ler '{embeddings_filepath}' dosyasına kaydedildi.")
+    except Exception as e:
+        logging.error(f"Embedding'ler kaydedilirken hata: {e}")
+    logging.info(f"{len(concept_embeddings)} konsept için ortalama embedding hesaplandı.")
+    return concept_embeddings
+def calculate_similarity_matrix(concept_embeddings: dict, force_recalculate: bool = False) -> pd.DataFrame | None:
+    """
+    Verilen embedding vektörleri arasındaki kosinüs benzerliğini hesaplar.
+    Hesaplanmış benzerlikleri yüklemeye çalışır, yoksa hesaplar.
+    Args:
+        concept_embeddings (dict[str, np.ndarray]): Concept ID -> Embedding Vektörü sözlüğü.
+        force_recalculate (bool): Daha önce hesaplanmış olsa bile yeniden hesaplamaya zorla.
+    Returns:
+        pd.DataFrame | None: 'concept_id_1', 'concept_id_2', 'similarity' sütunlarını
+                             içeren DataFrame veya hata durumunda None.
+    """
+    similarity_filepath = storage.DATA_PATH / f"{SIMILARITY_FILENAME}.parquet"
+    if not force_recalculate and similarity_filepath.exists():
+        try:
+            similarity_df = storage.load_dataframe(SIMILARITY_FILENAME, ['concept_id_1', 'concept_id_2', 'similarity'])
+            logging.info(f"Önceden hesaplanmış benzerlik matrisi '{similarity_filepath}' dosyasından yüklendi.")
+            if similarity_df is not None and not similarity_df.empty:
+                return similarity_df
+            else:
+                 logging.warning("Yüklenen benzerlik dosyası boş veya hatalı. Yeniden hesaplanacak.")
+        except Exception as e:
+            logging.error(f"Benzerlik matrisi yüklenirken hata: {e}. Yeniden hesaplanacak.")
+    if not concept_embeddings:
+        logging.error("Benzerlik hesaplamak için embedding verisi bulunamadı.")
+        return None
+    logging.info("Konseptler arası benzerlik matrisi hesaplanıyor...")
+    # Sözlükten sıralı liste ve matris oluştur
+    concept_ids = list(concept_embeddings.keys())
+    embedding_matrix = np.array(list(concept_embeddings.values()))
+    # Boyut kontrolü
+    if embedding_matrix.ndim != 2 or embedding_matrix.shape[0] != len(concept_ids):
+        logging.error(f"Embedding matrisinin boyutları ({embedding_matrix.shape}) beklenenden farklı.")
+        return None
+    # Kosinüs benzerliğini hesapla
+    try:
+        similarity_matrix = cosine_similarity(embedding_matrix)
+    except Exception as e:
+        logging.exception(f"Kosinüs benzerliği hesaplanırken hata: {e}")
+        return None
+    # Matrisi DataFrame'e dönüştür (uzun format)
+    similarity_data = []
+    num_concepts = len(concept_ids)
+    for i in range(num_concepts):
+        for j in range(i + 1, num_concepts): # Sadece üçgenin üstünü al (j > i) ve kendini (i=j) atla
+            similarity_data.append({
+                'concept_id_1': concept_ids[i],
+                'concept_id_2': concept_ids[j],
+                'similarity': similarity_matrix[i, j]
+            })
+    similarity_df = pd.DataFrame(similarity_data)
+    if similarity_df.empty:
+        logging.warning("Hesaplama sonucu benzerlik verisi üretilemedi.")
+        # Boş DataFrame kaydetmeyelim, None döndürelim
+        return None
+    # Hesaplanan benzerlikleri kaydet
+    storage.save_dataframe(similarity_df, SIMILARITY_FILENAME)
+    logging.info(f"Benzerlik matrisi hesaplandı ve kaydedildi. {len(similarity_df)} çift.")
+    return similarity_df

storage.py ADDED Viewed

	@@ -0,0 +1,150 @@

+# src/data_management/storage.py (TÜM SABİTLERİ İÇEREN DOĞRU TAM KOD)
+import pandas as pd
+from pathlib import Path
+import logging
+import uuid
+from datetime import datetime
+import networkx as nx
+import pickle
+import string
+# Temel veri klasörünün yolu
+DATA_PATH = Path("data/processed_data")
+# NetworkX graf dosyalarının yolu
+NETWORK_PATH = Path("output/networks")
+# --- TÜM GEREKLİ SABİT TANIMLARI ---
+FREQUENCY_FILENAME = "analysis_concept_frequencies"
+SIMILARITY_FILENAME = "analysis_concept_similarities"
+NETWORK_ANALYSIS_FILENAME = "analysis_network_results"
+GRAPH_FILENAME = "concept_network"
+EMBEDDINGS_FILENAME = "concept_embeddings"
+# ------------------------------------
+# DataFrame sütun isimleri
+DOC_COLUMNS = ['doc_id', 'filepath', 'publication_date', 'status', 'processed_text_path']
+CONCEPT_COLUMNS = ['concept_id', 'name', 'aliases']
+MENTION_COLUMNS = ['mention_id', 'doc_id', 'concept_id', 'context_snippet', 'start_char', 'end_char']
+RELATIONSHIP_COLUMNS = ['relationship_id', 'source_concept_id', 'target_concept_id', 'type', 'mention_id', 'doc_id', 'sentence']
+NETWORK_ANALYSIS_COLUMNS = ['concept_id', 'name', 'degree_centrality', 'betweenness_centrality', 'eigenvector_centrality', 'community_id']
+# Logging ayarları
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# --- DataFrame Yükleme/Kaydetme (Değişiklik yok) ---
+def load_dataframe(filename: str, columns: list) -> pd.DataFrame:
+    filepath = DATA_PATH / f"{filename}.parquet"
+    if filepath.exists():
+        try:
+            df = pd.read_parquet(filepath)
+            logging.info(f"'{filepath}' başarıyla yüklendi.")
+            if columns: # Check columns only if a list is provided
+                for col in columns:
+                    if col not in df.columns:
+                        logging.warning(f"'{filepath}' dosyasında '{col}' sütunu eksik. Ekleniyor...")
+                        df[col] = None
+            return df
+        except Exception as e:
+            logging.error(f"'{filepath}' yüklenirken hata oluştu: {e}")
+            return pd.DataFrame(columns=columns if columns else None)
+    else:
+        logging.info(f"'{filepath}' bulunamadı. Boş DataFrame oluşturuluyor.")
+        return pd.DataFrame(columns=columns if columns else None)
+def save_dataframe(df: pd.DataFrame, filename: str):
+    DATA_PATH.mkdir(parents=True, exist_ok=True)
+    filepath = DATA_PATH / f"{filename}.parquet"
+    try:
+        for col in df.select_dtypes(include=['object']).columns:
+             if df[col].map(type).isin([list, dict, datetime, pd.Timestamp]).any(): continue
+             df[col] = df[col].where(pd.notnull(df[col]), None)
+             try: df[col] = df[col].astype(pd.StringDtype())
+             except TypeError: logging.debug(f"Sütun '{col}' StringDtype'a çevrilemedi, orijinal tip korunuyor.")
+        df.to_parquet(filepath, index=False)
+        logging.info(f"DataFrame başarıyla '{filepath}' olarak kaydedildi.")
+    except Exception as e:
+        logging.error(f"DataFrame '{filepath}' olarak kaydedilirken hata oluştu: {e}")
+# --- Doküman Yönetimi (Değişiklik yok) ---
+def add_document(filepath_str: str, publication_date) -> str | None:
+    documents_df = load_dataframe('documents', DOC_COLUMNS)
+    filepath_str = str(Path(filepath_str).resolve())
+    existing_doc = documents_df[documents_df['filepath'] == filepath_str]
+    if not existing_doc.empty:
+        existing_doc_id = existing_doc['doc_id'].iloc[0]
+        logging.warning(f"Doküman zaten kayıtlı: {filepath_str} (ID: {existing_doc_id})")
+        return str(existing_doc_id)
+    new_doc_id = str(uuid.uuid4())
+    try: pub_date_obj = pd.to_datetime(publication_date).date()
+    except ValueError: logging.error(f"Geçersiz tarih formatı: {publication_date}. None olarak kaydedilecek."); pub_date_obj = None
+    new_document_data = {'doc_id': new_doc_id, 'filepath': filepath_str, 'publication_date': pub_date_obj, 'status': 'added', 'processed_text_path': None}
+    new_row_df = pd.DataFrame([new_document_data])
+    if pub_date_obj is not None: new_row_df['publication_date'] = pd.to_datetime(new_row_df['publication_date']); dtype_dict = {'publication_date': 'datetime64[s]'}
+    else: dtype_dict = {}
+    documents_df = pd.concat([documents_df, new_row_df], ignore_index=True)
+    for col, dtype in dtype_dict.items():
+        try: documents_df[col] = documents_df[col].astype(dtype)
+        except TypeError: logging.warning(f"Sütun '{col}' tipi '{dtype}' olarak ayarlanamadı.")
+    save_dataframe(documents_df, 'documents')
+    logging.info(f"Yeni doküman eklendi: {filepath_str} (ID: {new_doc_id})")
+    return new_doc_id
+def update_document_status(doc_id: str, new_status: str, text_path: str | None = None):
+    docs_df = load_dataframe('documents', DOC_COLUMNS)
+    doc_index = docs_df[docs_df['doc_id'] == doc_id].index
+    if not doc_index.empty:
+        idx = doc_index[0]
+        docs_df.loc[idx, 'status'] = new_status
+        if text_path: docs_df.loc[idx, 'processed_text_path'] = text_path
+        save_dataframe(docs_df, 'documents')
+        logging.info(f"Doküman durumu güncellendi: ID {doc_id} -> {new_status}")
+    else: logging.warning(f"Durumu güncellenecek doküman bulunamadı: ID {doc_id}")
+# --- Konsept, Mention, İlişki Yönetimi (Değişiklik yok) ---
+def add_concept(raw_name: str) -> str | None:
+    concepts_df = load_dataframe('concepts', CONCEPT_COLUMNS)
+    name = raw_name.lower().strip().strip(string.punctuation + string.whitespace)
+    if name.endswith("'s"): name = name[:-2].strip()
+    name = ' '.join(name.split())
+    if not name or len(name) < 2: return None
+    existing_concept = concepts_df[concepts_df['name'] == name]
+    if not existing_concept.empty: return str(existing_concept['concept_id'].iloc[0])
+    new_concept_id = str(uuid.uuid4()); new_concept_data = {'concept_id': new_concept_id, 'name': name, 'aliases': [raw_name]}
+    new_row_df = pd.DataFrame([new_concept_data]); concepts_df = pd.concat([concepts_df, new_row_df], ignore_index=True)
+    concepts_df['aliases'] = concepts_df['aliases'].astype('object')
+    save_dataframe(concepts_df, 'concepts')
+    logging.info(f"Yeni konsept eklendi: '{name}' (Orijinal: '{raw_name}', ID: {new_concept_id})")
+    return new_concept_id
+def add_mention(doc_id: str, concept_id: str, context: str, start: int, end: int) -> str | None:
+    if concept_id is None: return None
+    mentions_df = load_dataframe('mentions', MENTION_COLUMNS); new_mention_id = str(uuid.uuid4())
+    new_mention_data = {'mention_id': new_mention_id, 'doc_id': doc_id, 'concept_id': concept_id, 'context_snippet': context[:500], 'start_char': start, 'end_char': end}
+    new_row_df = pd.DataFrame([new_mention_data]); mentions_df = pd.concat([mentions_df, new_row_df], ignore_index=True)
+    save_dataframe(mentions_df, 'mentions'); return new_mention_id
+def add_relationship(source_concept_id: str, target_concept_id: str, rel_type: str, mention_id: str | None, doc_id: str, sentence: str) -> str | None:
+    if source_concept_id is None or target_concept_id is None: return None
+    relationships_df = load_dataframe('relationships', RELATIONSHIP_COLUMNS); new_relationship_id = str(uuid.uuid4())
+    new_relationship_data = {'relationship_id': new_relationship_id, 'source_concept_id': source_concept_id, 'target_concept_id': target_concept_id, 'type': rel_type, 'mention_id': mention_id, 'doc_id': doc_id, 'sentence': sentence[:500]}
+    new_row_df = pd.DataFrame([new_relationship_data]); relationships_df = pd.concat([relationships_df, new_row_df], ignore_index=True)
+    save_dataframe(relationships_df, 'relationships'); return new_relationship_id
+# --- NetworkX Graf Yükleme/Kaydetme (Değişiklik yok) ---
+def save_network(graph: nx.Graph, filename: str):
+    NETWORK_PATH.mkdir(parents=True, exist_ok=True); filepath = NETWORK_PATH / f"{filename}.pkl"
+    try:
+        with open(filepath, 'wb') as f: pickle.dump(graph, f)
+        logging.info(f"NetworkX grafı başarıyla '{filepath}' olarak kaydedildi.")
+    except Exception as e: logging.error(f"Graf '{filepath}' olarak kaydedilirken hata: {e}")
+def load_network(filename: str) -> nx.Graph | None:
+    filepath = NETWORK_PATH / f"{filename}.pkl"
+    if filepath.exists():
+        try:
+            with open(filepath, 'rb') as f: graph = pickle.load(f)
+            logging.info(f"NetworkX grafı '{filepath}' başarıyla yüklendi.")
+            return graph
+        except Exception as e: logging.error(f"Graf '{filepath}' yüklenirken hata: {e}"); return nx.Graph()
+    else: logging.warning(f"Graf dosyası bulunamadı: '{filepath}'"); return nx.Graph()

temporal.py ADDED Viewed

	@@ -0,0 +1,164 @@

+# src/analysis/temporal.py (Yarı ömür fonksiyonu eklendi)
+import pandas as pd
+import numpy as np
+from scipy.optimize import curve_fit
+import logging
+from pathlib import Path
+from datetime import datetime
+# Yerel modüllerimizi içe aktaralım
+from src.data_management import storage
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+def calculate_concept_frequencies(time_period: str = 'Y') -> pd.DataFrame | None:
+    """
+    Konseptlerin zaman içindeki kullanım sıklıklarını hesaplar. (Önceki kodla aynı)
+    """
+    logging.info(f"Konsept frekansları '{time_period}' periyodu için hesaplanıyor...")
+    mentions_df = storage.load_dataframe('mentions', storage.MENTION_COLUMNS)
+    documents_df = storage.load_dataframe('documents', storage.DOC_COLUMNS)
+    if mentions_df is None or documents_df is None:
+        logging.error("Mention veya Document verisi yüklenemedi. Frekans hesaplanamıyor.")
+        return None
+    if mentions_df.empty:
+        logging.warning("Mention verisi boş. Frekans hesaplanamıyor.")
+        return pd.DataFrame(columns=['concept_id', 'time_period_start', 'frequency'])
+    if documents_df.empty:
+        logging.warning("Document verisi boş. Tarih bilgisi alınamıyor, frekans hesaplanamıyor.")
+        return pd.DataFrame(columns=['concept_id', 'time_period_start', 'frequency'])
+    docs_subset = documents_df[['doc_id', 'publication_date']].copy()
+    try:
+        docs_subset['publication_date'] = pd.to_datetime(docs_subset['publication_date'], errors='coerce')
+    except Exception as e:
+         logging.error(f"Dokümanlardaki 'publication_date' sütunu datetime'a çevrilemedi: {e}")
+         return None
+    original_doc_count = len(docs_subset)
+    docs_subset.dropna(subset=['publication_date'], inplace=True)
+    valid_date_count = len(docs_subset)
+    if original_doc_count > valid_date_count:
+        logging.warning(f"{original_doc_count - valid_date_count} dokümanın geçerli yayın tarihi yok, frekans hesaplamasına dahil edilmeyecek.")
+    if docs_subset.empty:
+        logging.warning("Geçerli yayın tarihine sahip doküman bulunamadı. Frekans hesaplanamıyor.")
+        return pd.DataFrame(columns=['concept_id', 'time_period_start', 'frequency'])
+    mentions_with_dates = pd.merge(mentions_df, docs_subset, on='doc_id', how='inner')
+    if mentions_with_dates.empty:
+        logging.warning("Mention'lar ile doküman tarihleri birleştirilemedi veya sonuç boş.")
+        return pd.DataFrame(columns=['concept_id', 'time_period_start', 'frequency'])
+    logging.info(f"{len(mentions_with_dates)} mention için tarih bilgisi bulundu.")
+    try:
+        frequency_df = mentions_with_dates.groupby(
+            ['concept_id', pd.Grouper(key='publication_date', freq=time_period)]
+        ).size().reset_index(name='frequency')
+        frequency_df.rename(columns={'publication_date': 'time_period_start'}, inplace=True)
+        logging.info(f"Frekans hesaplaması tamamlandı. {len(frequency_df)} satır sonuç üretildi.")
+        frequency_df.sort_values(by=['concept_id', 'time_period_start'], inplace=True)
+        return frequency_df
+    except Exception as e:
+        logging.exception(f"Frekans hesaplanırken hata oluştu: {e}")
+        return None
+# --- YENİ: Yarı Ömür Hesaplama ---
+def exponential_decay(t, A, decay_rate):
+    """Üstel bozulma fonksiyonu: A * exp(-decay_rate * t)."""
+    # Decay rate negatif olmamalı (bozunma varsayımı)
+    decay_rate = max(0, decay_rate) # Negatifse sıfır yap
+    return A * np.exp(-decay_rate * t)
+def calculate_half_life(concept_id: str,
+                        frequency_df: pd.DataFrame,
+                        concept_name: str | None = None,
+                        min_data_points: int = 4,
+                        min_decay_rate: float = 1e-6) -> float | None:
+    """
+    Verilen konsept için frekans verisine üstel bozulma modeli uygulayarak
+    yarı ömrü (yıl olarak) hesaplar.
+    Args:
+        concept_id (str): Hesaplanacak konseptin ID'si.
+        frequency_df (pd.DataFrame): calculate_concept_frequencies'ten dönen DataFrame.
+                                     ('concept_id', 'time_period_start', 'frequency' sütunları olmalı).
+        concept_name (str | None): Loglama için konseptin adı (opsiyonel).
+        min_data_points (int): Yarı ömür hesaplamak için gereken minimum zaman noktası sayısı.
+        min_decay_rate (float): Kabul edilebilir minimum bozunma oranı (çok küçükse yarı ömür sonsuz kabul edilir).
+    Returns:
+        float | None: Hesaplanan yarı ömür (yıl olarak) veya hesaplanamazsa None.
+                      np.inf dönebilir eğer bozunma oranı çok küçükse.
+    """
+    log_prefix = f"Yarı Ömür ({concept_name or concept_id}):"
+    if frequency_df is None or frequency_df.empty:
+        logging.warning(f"{log_prefix} Frekans verisi boş.")
+        return None
+    # Konsepte ait veriyi filtrele ve zamana göre sırala
+    concept_data = frequency_df[frequency_df['concept_id'] == concept_id].sort_values(by='time_period_start').copy()
+    # Yeterli veri noktası var mı?
+    if len(concept_data) < min_data_points:
+        logging.info(f"{log_prefix} Yeterli veri noktası yok ({len(concept_data)} < {min_data_points}). Hesaplama yapılamıyor.")
+        return None
+    # Zamanı sayısal değere çevir (ilk yıldan itibaren geçen yıl sayısı)
+    try:
+        # İlk zaman noktasını t=0 kabul et
+        start_date = concept_data['time_period_start'].min()
+        # Zaman farkını gün olarak hesapla ve yıla çevir
+        concept_data['time_elapsed_years'] = (concept_data['time_period_start'] - start_date).dt.days / 365.25
+    except Exception as e:
+        logging.error(f"{log_prefix} Zaman farkı hesaplanırken hata: {e}")
+        return None
+    time_values = concept_data['time_elapsed_years'].values
+    frequency_values = concept_data['frequency'].values
+    # Frekanslar artıyor mu veya sabit mi kontrol et (basit kontrol)
+    # Eğer son değer ilk değerden büyükse veya tüm değerler aynıysa, bozunma yok kabul et
+    if frequency_values[-1] > frequency_values[0] or np.all(frequency_values == frequency_values[0]):
+         logging.info(f"{log_prefix} Veride belirgin bir azalma gözlenmedi. Yarı ömür hesaplanamıyor.")
+         return None # Veya np.inf? Şimdilik None.
+    # Modeli uydurmak için başlangıç tahminleri
+    initial_A_guess = frequency_values[0] # İlk frekans değeri
+    initial_lambda_guess = 0.1 # Küçük pozitif bir bozunma oranı tahmini
+    try:
+        # curve_fit ile modeli verilere uydur
+        params, covariance = curve_fit(
+            exponential_decay,
+            time_values,
+            frequency_values,
+            p0=[initial_A_guess, initial_lambda_guess],
+            bounds=([0, 0], [np.inf, np.inf]) # Parametrelerin pozitif olmasını sağla
+            # maxfev artırılabilir eğer "Optimal parameters not found" hatası alınırsa
+        )
+        A_fit, decay_rate_fit = params
+        # Bozunma oranı anlamlı mı?
+        if decay_rate_fit < min_decay_rate:
+            logging.info(f"{log_prefix} Hesaplanan bozunma oranı ({decay_rate_fit:.4f}) çok düşük. Yarı ömür sonsuz kabul ediliyor.")
+            return np.inf # Sonsuz yarı ömür
+        # Yarı ömrü hesapla: ln(2) / decay_rate
+        half_life_years = np.log(2) / decay_rate_fit
+        logging.info(f"{log_prefix} Başarıyla hesaplandı. A={A_fit:.2f}, Bozunma Oranı={decay_rate_fit:.4f}, Yarı Ömür={half_life_years:.2f} yıl.")
+        return half_life_years
+    except RuntimeError as e:
+        logging.warning(f"{log_prefix} Üstel bozulma modeli uydurulamadı: {e}. Yarı ömür hesaplanamıyor.")
+        return None
+    except Exception as e:
+        logging.exception(f"{log_prefix} Yarı ömür hesaplanırken beklenmeyen hata: {e}")
+        return None

test1.png ADDED Viewed