Update app.py

app.py

@@ -5,107 +5,106 @@ import json
 from io import StringIO
 
 
-def dynamic_huff_model(df_distances, df_attractiveness, alpha, beta, df_capacity, df_population=None, iterations=5, crowding_threshold=1.0):
+def adjust_population_by_distance(df_distances, df_population, distance_threshold, decay_factor):
     """
-    Iteratively calculates the distribution of people/visitors to destinations considering capacity and crowding based on an extended Huff model with linear decay function.
+    Adjusts the population of each origin based on the distance to any destination, applying a decay effect for distances beyond the threshold.
 
     Parameters:
-    - df_distances, df_attractiveness, alpha, beta, df_capacity, df_population are the same as before.
-    - iterations (int): The number of iterations to distribute the population.
-    - crowding_threshold (float): The ratio of current visitors to capacity at which the decay of attractiveness starts.
+    - df_distances (pd.DataFrame): DataFrame with distances from origins to destinations.
+    - df_population (pd.Series): Series with population for each origin.
+    - distance_threshold (float): Distance beyond which the decay effect is applied.
+    - decay_factor (float): Factor controlling the rate of decay in willingness to travel beyond the threshold.
 
     Returns:
-    - pd.DataFrame: A DataFrame with the final distribution of visitors to each destination.
+    - pd.Series: Adjusted population for each origin.
     """
+    # Calculate the minimum distance from each origin to any destination
+    min_distance = df_distances.min(axis=1)
 
-    print("====== PRAMETER =====")
-    print("alpha",alpha)
-    print("beta",beta)
-    print("iterations",iterations)
-    print("crowding_threshold",crowding_threshold)
-    print("=====================")
-    
-    
+    # Adjust the population based on the minimum distance and the decay factor
+    def adjustment_factor(distance):
+        if distance > distance_threshold:
+            return np.exp(-(distance - distance_threshold) * decay_factor)
+        else:
+            return 1
+
+    adjustment_factors = min_distance.apply(adjustment_factor)
+    return df_population * adjustment_factors
+
+def huff_model_probability(df_distances, df_attractiveness, alpha, beta, df_population=None, distance_threshold=None, decay_factor=0.1):
+    """
+    Calculates the probability of choosing among destinations based on an enhanced Huff model that considers a willingness to travel threshold and applies a decay effect for distances beyond this threshold.
+
+    Parameters:
+    - df_distances (pd.DataFrame): DataFrame where rows are origins, columns are destinations, and values are distances.
+    - df_attractiveness (pd.Series): Series with attractiveness weights for each destination.
+    - alpha (float): Attractiveness parameter of the Huff model.
+    - beta (float): Distance decay parameter of the Huff model.
+    - df_population (pd.Series, optional): Series with population for each origin. Defaults to 1 if not provided.
+    - distance_threshold (float, optional): Distance beyond which the decay effect on willingness to travel is applied.
+    - decay_factor (float, optional): Factor controlling the rate of decay in willingness to travel beyond the threshold.
+
+    Returns:
+    - pd.DataFrame: DataFrame with probabilities of choosing each destination from each origin.
+    """
     if df_population is None:
         df_population = pd.Series(np.ones(df_distances.shape[0]), index=df_distances.index)
 
-    # Initialize the visitors DataFrame
-    df_visitors = pd.DataFrame(0, index=df_distances.index, columns=df_distances.columns)
-    
-    # Distribute the population over the iterations
-    df_population_per_iteration = df_population / iterations
-
-    # Run the iterative distribution process
-    for i in range(int(iterations)):
-        print("iteration " + str(i) + "/"+str(int(iterations)))
-        attractiveness = df_attractiveness.copy()
-        current_visitors = df_visitors.sum(axis=0)
-        
-        # Calculate the decay based on the relative share of free capacity
-        print(" Calculate the decay based on the relative share of free capacity")
-        relative_crowding = current_visitors / df_capacity
-        decay_factor = np.where(relative_crowding < crowding_threshold, 1, 1 - (relative_crowding - crowding_threshold) / (1 - crowding_threshold))
-        attractiveness *= decay_factor
-        
-        # Calculate Huff model probabilities
-        print("Calculate Huff model probabilities")
-        distance_term = df_distances ** -beta
-        # If df_distances is a DataFrame and df_attractiveness is a Series, you might need an operation like:
-        numerator = df_distances.multiply(df_attractiveness, axis=0)  # Adjust based on actual intent
-
-        denominator = numerator.sum(axis='columns')
-        probabilities = numerator.div(denominator, axis='index').fillna(0)
-
-        print("Distribute visitors based on probabilities and population")
-        # Distribute visitors based on probabilities and population
-        visitors_this_iteration = probabilities.multiply(df_population_per_iteration, axis='index')
-        
-        # Adjust for excess visitors beyond capacity
-        potential_new_visitors = df_visitors + visitors_this_iteration
-        excess_visitors = potential_new_visitors.sum(axis=0) - df_capacity
-        excess_visitors[excess_visitors < 0] = 0
-        visitors_this_iteration -= visitors_this_iteration.multiply(excess_visitors, axis='columns') / visitors_this_iteration.sum(axis=0)
-        
-        df_visitors += visitors_this_iteration
-
-    # Return the final distribution of visitors
-    return df_visitors
+    if distance_threshold is not None:
+        df_population = adjust_population_by_distance(df_distances, df_population, distance_threshold, decay_factor)
+
+    attractiveness_term = df_attractiveness ** alpha
+    distance_term = df_distances ** -beta
+
+    numerator = (attractiveness_term * distance_term).multiply(df_population, axis=0)
+    denominator = numerator.sum(axis=1)
+    probabilities = numerator.div(denominator, axis=0)
+
+    return probabilities
 
 def app_function(input_json):
-    print("something happend")
+    print("Received input")
     # Parse the input JSON string
-    print(input_json)
-
     try:
         inputs = json.loads(input_json)
-    except:
+    except json.JSONDecodeError:
         inputs = json.loads(input_json.replace("'", '"'))
-    print(inputs.keys())
-    # navigate to payload
+    print("Parsed input keys:", inputs.keys())
+
+    # Assuming the input structure is correctly formatted to include the necessary parameters
     inputs = inputs["input"]
 
-    print(inputs.keys())
-    # Convert 'df_distances' from a list of lists into a DataFrame directly
+    # Convert 'df_distances' from a list of lists into a DataFrame
     df_distances = pd.DataFrame(inputs["df_distances"])
-    print("df_distances shape", df_distances.shape)
-    # 'inputs["df_attractiveness"]' and others are directly usable as lists
+    print("df_distances shape:", df_distances.shape)
+    
+    # Convert 'df_attractiveness' into a Series
     df_attractiveness = pd.Series(inputs["df_attractiveness"])
-    print("df_attractiveness shape", df_attractiveness.shape)
+    print("df_attractiveness shape:", df_attractiveness.shape)
+    
+    # Extract alpha and beta parameters
     alpha = inputs["alpha"]
     beta = inputs["beta"]
-    df_capacity = pd.Series(inputs["df_capacity"])
     
-    # Check if 'df_population' is provided and convert to Series
+    # Check if 'df_population' is provided and convert to Series, else default to None
     df_population = pd.Series(inputs["df_population"]) if "df_population" in inputs else None
+
+    # Additional parameters for the updated Huff model
+    distance_threshold = inputs.get("distance_threshold", None)
+    decay_factor = inputs.get("decay_factor", 0.1)  # Default decay factor if not provided
     
-    iterations = int(inputs.get("iterations", 5))
-    crowding_threshold = inputs.get("crowding_threshold", 1.0)
-    
-    # Assuming dynamic_huff_model function is correctly defined to accept these parameters
-    result = dynamic_huff_model(df_distances, df_attractiveness, alpha, beta, df_capacity, df_population, iterations, crowding_threshold)
-    print(result)
-    # Convert the result DataFrame to a JSON string for output
-    return result.to_json(orient='split')
+    # Call the updated Huff model function
+    probabilities = huff_model_probability(
+        df_distances=df_distances,
+        df_attractiveness=df_attractiveness,
+        alpha=alpha,
+        beta=beta,
+        df_population=df_population,
+        distance_threshold=distance_threshold,
+        decay_factor=decay_factor
+    )
+
+    return probabilities.to_json(orient='split')
 
 # Define the Gradio interface with a single JSON input
 iface = gr.Interface(