Update README.md

README.md

@@ -103,12 +103,23 @@ from transformers import AutoModelForCausalLM, AutoTokenizer
 device = "cuda"
 model = AutoModelForCausalLM.from_pretrained("PipableAI/pip-code-to-doc-1.3b").to(device)
 tokenizer = AutoTokenizer.from_pretrained("PipableAI/pip-code-to-doc-1.3b")
-prompt = f"""
+prompt = f"""<example_response>
+--code:def function_2(x): return x / 2
+--question:Document the code
+--doc:
+    Description:This function takes a number and divides it by 2.
+    Parameters:
+    - x (numeric): The input value to be divided by 2.
+    Returns:
+    - float: The result of x divided by 2
+    Example:
+    To call the function, use the following code:
+    function2(1.0)</example_response>
 <function_code>
 def example_function(x):
     return x * 2
 </function_code>
-<question>Give one line description of the python code above in natural language.</question>
+<question>Document the python code above giving function description ,parameters and return type and example how to call the function.</question>
 <doc>"""
 inputs = tokenizer(prompt, return_tensors="pt")
 outputs = model.generate(**inputs, max_new_tokens=300)
@@ -121,95 +132,85 @@ tokenizer.decode(outputs[0], skip_special_tokens=True).split('<doc>')[-1].split(
 
 ### prompt
 ```python
-<function_code>
-###########################
-# Generate Analytical Model
-###########################
-##################################################
-# func: get_np_array_transition_probability_matrix
-##################################################
-def get_np_array_transition_probability_matrix(int_num_states, np_array_A_matrix):
-    print('np_array_A_matrix:')
-    print(np_array_A_matrix)
-    #####################################################
-    # Perturb the adjacency matrix to avoid singularities
-    #####################################################
-    np_array_A_matrix += (np.full((int_num_states, int_num_states), float_eps) - (np.identity(int_num_states) * float_eps))
-    print('np_array_A_matrix:')
-    print(np_array_A_matrix)
-    print('np_array_D_matrix:')
-    np_array_D_matrix = np.diag(np.sum(np_array_A_matrix, axis=1))
-    print(np_array_D_matrix)
-    print('np_array_D_matrix_inv:')
-    np_array_D_matrix_inv = np.linalg.inv(np_array_D_matrix)
-    print(np_array_D_matrix_inv)
-    print('\n\n')
-    print('np_array_P_matrix:')
-    np_array_P_matrix = np.dot(np_array_D_matrix_inv, np_array_A_matrix)
-    print(np_array_P_matrix)
-    print('np.sum(np_array_P_matrix, axis=1):')
-    print(np.sum(np_array_P_matrix, axis=1))
-    print('\n\n')
-    return np_array_P_matrix
-##################################################
-# func: get_np_array_perron_frobenius_eigen_vector
-##################################################
-def get_np_array_perron_frobenius_matrix(int_num_states, np_array_P_matrix):
-    np_array_perron_frobenius_matrix = np.linalg.matrix_power(np_array_P_matrix,1000)
-    np_array_perron_frobenius_vector = np_array_perron_frobenius_matrix[0,:]
-    print('np_array_perron_frobenius_matrix:')
-    print(np_array_perron_frobenius_matrix)
-    print('np.sum(np_array_perron_frobenius_matrix, axis=1):')
-    print(np.sum(np_array_perron_frobenius_matrix, axis=1))
-    print('np.sum(np_array_perron_frobenius_matrix, axis=0):')
-    print(np.sum(np_array_perron_frobenius_matrix, axis=0))
-    print('np.sum(np_array_perron_frobenius_matrix, axis=0)/int_num_states:')
-    print(np.sum(np_array_perron_frobenius_matrix, axis=0)/int_num_states)
-    print('np.dot(np_array_perron_frobenius_vector, np_array_P_matrix):')
-    print(np.dot(np_array_perron_frobenius_vector, np_array_P_matrix))
-    print('np_array_perron_frobenius_vector:')
-    print(np_array_perron_frobenius_vector)
-    print('\n\n')
-    return np_array_perron_frobenius_vector, np_array_perron_frobenius_matrix
-#############################
-# func: get_np_array_Z_matrix
-#############################
-def get_np_array_Z_matrix(int_num_states, np_array_P_matrix, np_array_perron_frobenius_matrix):
-    np_array_Z_matrix = np.linalg.inv(np.identity(int_num_states) - np_array_P_matrix + np_array_perron_frobenius_matrix)
-    print('np_array_Z_matrix:')
-    print(np_array_Z_matrix)
-    print('\n\n')
-    return(np_array_Z_matrix)
-#############################
-# func: get_np_array_H_matrix
-#############################
-def get_np_array_H_matrix(int_num_states, np_array_Z_matrix, np_array_perron_frobenius_vector):
-    np_array_H_matrix = np.zeros([int_num_states, int_num_states])
-    for i in range(int_num_states):
-        for j in range(int_num_states):
-            np_array_H_matrix[i][j] = (np_array_Z_matrix[j][j] - np_array_Z_matrix[i][j])/np_array_perron_frobenius_vector[j]
-    print('np_array_H_matrix:')
-    print(np_array_H_matrix)
-    print('\n\n')
-    return np_array_H_matrix
-###########
-# func: run
-###########
-def run(np_array_A_matrix):
-    int_num_states = len(np_array_A_matrix)
-    np_array_P_matrix = get_np_array_transition_probability_matrix(int_num_states, np_array_A_matrix)
-    np_array_perron_frobenius_vector, np_array_perron_frobenius_matrix = get_np_array_perron_frobenius_matrix(int_num_states, np_array_P_matrix)
-    np_array_Z_matrix = get_np_array_Z_matrix(int_num_states, np_array_P_matrix, np_array_perron_frobenius_matrix)
-    np_array_H_matrix = get_np_array_H_matrix(int_num_states, np_array_Z_matrix, np_array_perron_frobenius_vector)
-    return(np_array_H_matrix)
-</function_code>
-<question>Give one line description of the python code above in natural language.</question>
-<doc>
+text=''' <example_response>
+--code:def function_2(x): return x / 2
+--question:Document the code
+--doc:
+    Description:This function takes a number and divides it by 2.
+    Parameters:
+    - x (numeric): The input value to be divided by 2.
+    Returns:
+    - float: The result of x divided by 2
+    Example:
+    To call the function, use the following code:
+    function2(1.0)</example_response>
+<function_code>def _plot_bounding_polygon(
+    polygons_coordinates, output_html_path="bounding_polygon_map.html"
+):
+    # Create a Folium map centered at the average coordinates of all bounding boxes
+    map_center = [
+        sum(
+            [
+                coord[0]
+                for polygon_coords in polygons_coordinates
+                for coord in polygon_coords
+            ]
+        )
+        / sum([len(polygon_coords) for polygon_coords in polygons_coordinates]),
+        sum(
+            [
+                coord[1]
+                for polygon_coords in polygons_coordinates
+                for coord in polygon_coords
+            ]
+        )
+        / sum([len(polygon_coords) for polygon_coords in polygons_coordinates]),
+    ]
+
+    my_map = folium.Map(location=map_center, zoom_start=12)
+
+    # Add each bounding polygon to the map
+    for polygon_coords in polygons_coordinates:
+        folium.Polygon(
+            locations=polygon_coords,
+            color="blue",
+            fill=True,
+            fill_color="blue",
+            fill_opacity=0.2,
+        ).add_to(my_map)
+
+    # Add bounding boxes as markers to the map
+    marker_cluster = MarkerCluster().add_to(my_map)
+
+    for polygon_coords in polygons_coordinates:
+        for coord in polygon_coords:
+            folium.Marker(
+                location=[coord[0], coord[1]], popup=f"Coordinates: {coord}"
+            ).add_to(marker_cluster)
+
+    # Add draw control to allow users to draw additional polygons
+    draw = Draw(export=True)
+    draw.add_to(my_map)
+
+    # Save the map as an HTML file
+    my_map.save(output_html_path)
+
+    return output_html_path
+    </function_code>
+    <question>Document the python code above giving function description ,parameters and return type and example how to call the function</question><doc>'''
 ```
 
 ### Response
 ```txt
-The given python code is a function that calculates the transition probability matrix, P, for a given adjacency matrix A, and then uses these matrices to calculate the Perron-Frobenius eigenvector and its inverse matrix Z, and finally, the H matrix which is the inverse of the Z matrix. The H matrix is then returned as the output of the function. The adjacency matrix A is a square matrix where each element at position (i, j) represents the probability of transitioning from state i to state j. The function first perturbs the adjacency matrix to avoid singularities, then calculates the transition probability matrix P, the Perron-Frobenius eigenvector and its inverse matrix Z, and finally, the H matrix. The H matrix is then returned as the output of the function.
+ Description:This function generates a map of the bounding polygons and saves it as an HTML file.
+    Parameters:
+    - polygons_coordinates (list of lists of tuples): A list of lists of tuples representing the coordinates of the polygons. Each polygon is a list of coordinates.
+    - output_html_path (str, optional): The path where the HTML file should be saved. Defaults to "bounding_polygon_map.html".
+    Returns:
+    - str: The path to the saved HTML file.
+    Example:
+    To call the function, use the following code:
+    plot_bounding_polygon([[(0, 0), (1, 0), (1, 1), (0, 1)], [(2, 2), (3, 2), (3, 3), (2, 3)]], "my_map.html").
 ```
 
 ### Team