Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-scout-17b-16e-instruct· MetaHugging Face Arena Expert 5K

from typing import ( Dict, List, Optional, Tuple, ) import numpy as np from…

  1. User

    from typing import ( Dict, List, Optional, Tuple, ) import numpy as np from sklearn.neighbors import KDTree # type: ignore[import-untyped]

    import h3 # type: ignore[import-untyped]

    from long_term_rent_model.constants import ( BIG_CITY_THRESHOLD, HUGE_CITY_THRESHOLD, MIDDLE_CITY_THRESHOLD, ) from long_term_rent_model.schemas.db import ( CityCoords, SberAnaliticsInfo, ) from long_term_rent_model.schemas.models import ( EnrichedGeoSchema, InputSchema, ) from long_term_rent_model.utils.features import haversine

    class GeoFeaturesEnricher: _city_coords: List[CityCoords] = [] _city_trees: Dict[str, KDTree] = {} _city_coords_by_type: Dict[str, np.ndarray] = {} _city_data_by_type: Dict[str, List[CityCoords]] = {}

    @classmethod
    def init_city_coords(cls, city_coords: List[CityCoords]):
        cls._city_coords = city_coords
    
        # ТОЧНОЕ соответствие calculate_nearest_distance
        huge_cities = []
        big_cities = []
        middle_cities = []
        small_cities = []
    
        for city in city_coords:
            if city.city_population >= HUGE_CITY_THRESHOLD:  # 1000000
                huge_cities.append(city)
            elif city.city_population >= BIG_CITY_THRESHOLD:  # 300000
                big_cities.append(city)
            elif city.city_population >= MIDDLE_CITY_THRESHOLD:  # 75000
                middle_cities.append(city)
            elif city.city_population < MIDDLE_CITY_THRESHOLD:  # < 75000 - SMALL
                small_cities.append(city)
    
        cls._city_data_by_type = {
            'huge': huge_cities,
            'big': big_cities,
            'middle': middle_cities,
            'small': small_cities
        }
    
        for city_type, cities in cls._city_data_by_type.items():
            if cities:
                coords_array = np.array([[city.lat, city.lon] for city in cities])
                cls._city_coords_by_type[city_type] = coords_array
                cls._city_trees[city_type] = KDTree(coords_array, metric='euclidean')
            else:
                cls._city_trees[city_type] = None
    
    @classmethod
    def enrich_data(
        cls,
        house_info: InputSchema,
    ) -> EnrichedGeoSchema:
        enriched = EnrichedGeoSchema(**(house_info.model_dump()))
    
        house_coords = np.array([[house_info.lat, house_info.lon]])
    
        # Обрабатываем только huge, big, small - как в исходной enrich_data
        for city_type in ['huge', 'big', 'small']:
            if (cls._city_trees.get(city_type) is not None and
                len(cls._city_data_by_type[city_type]) > 0):
    
                try:
                    # Находим ближайший город через KDTree
                    distances, indices = cls._city_trees[city_type].query(house_coords, k=1)
                    nearest_city_idx = indices[0][0]
    
                    if nearest_city_idx < len(cls._city_data_by_type[city_type]):
                        nearest_city = cls._city_data_by_type[city_type][nearest_city_idx]
    
                        # Вычисляем haversine расстояние
                        dist = haversine(
                            house_info.lat, house_info.lon,
                            nearest_city.lat, nearest_city.lon
                        )
                        dist = round(dist, 6)
    
                        # Устанавливаем расстояние
                        if city_type == 'huge':
                            enriched.dist_to_huge_city = dist
                        elif city_type == 'big':
                            enriched.dist_to_big_city = dist
                        elif city_type == 'small':
                            enriched.dist_to_small_city = dist
    
                except Exception as e:
                    # Fallback: переборный алгоритм как в оригинале
                    min_dist = None
                    for city in cls._city_data_by_type[city_type]:
                        dist = haversine(house_info.lat, house_info.lon, city.lat, city.lon)
                        dist = round(dist, 6)
                        min_dist = cls.min_with_none(dist, min_dist)
    
                    if min_dist is not None:
                        if city_type == 'huge':
                            enriched.dist_to_huge_city = min_dist
                        elif city_type == 'big':
                            enriched.dist_to_big_city = min_dist
                        elif city_type == 'small':
                            enriched.dist_to_small_city = min_dist
    
        return enriched
    
    @classmethod
    def min_with_none(cls, computed_dist: float, cur_dist: Optional[float]) -> float:
        if cur_dist is None:
            return computed_dist
        return min(cur_dist, computed_dist)
    

    def calculate_nearest_distance(df, city_pop, lat_col='lat', lon_col='lon'): city_types = {'huge': city_pop.loc[city_pop['city_population'] >= 1000000], 'big': city_pop.loc[(city_pop['city_population'] < 1000000) & (city_pop['city_population'] >= 300000)], 'middle': city_pop.loc[(city_pop['city_population'] < 300000) & (city_pop['city_population'] >= 75000)], 'small': city_pop.loc[(city_pop['city_population'] < 75000)]}

    for city_type, city_df in city_types.items():
        land_coords = df[[lat_col, lon_col]].values
        city_coords = city_df[[lat_col, lon_col]].values
    
        tree = KDTree(city_coords, metric='euclidean')
        _, indices = tree.query(land_coords, k=1)
    
        result_df = df[[lat_col, lon_col]].copy()
        result_df[f'nearest_city_{lat_col}'] = city_df[lat_col].iloc[indices[:, 0]].values
        result_df[f'nearest_city_{lon_col}'] = city_df[lon_col].iloc[indices[:, 0]].values
    
        distances = haversine(result_df['lat'].values,
                              result_df['lon'].values,
                              result_df[f'nearest_city_{lat_col}'].values,
                              result_df[f'nearest_city_{lon_col}'].values)
    
        df[f'dist_to_{city_type}_city'] = distances
    
    return df
    

    есть 2 функции нужно понять почему именно для small_cities первая выводит значения, которые не совпаают со второй

  2. Meta Assistant

    После анализа кода, я нашел несколько потенциальных причин, почему значения для small_cities могут не совпадать между двумя функциями:

    1. Различия в расчете расстояний: В функции GeoFeaturesEnricher.enrich_data используется класс KDTree из sklearn.neighbors с метрикой euclidean, чтобы найти ближайший город. Однако, в функции calculate_nearest_distance используется та же метрика euclidean для KDTree, но расстояния рассчитываются с помощью функции haversine, которая использует сферическую тригонометрию для расчета расстояний между двумя точками на сфере (Земле). Хотя это не должно быть причиной различий, но стоит проверить, что обе функции используют одинаковые координаты и единицы измерения.

    2. Различия в отборе городов: В функции GeoFeaturesEnricher.init_city_coords города отбираются по типу (huge, big, middle, small) на основе порогов (HUGE_CITY_THRESHOLD, BIG_CITY_THRESHOLD, MIDDLE_CITY_THRESHOLD). В функции calculate_nearest_distance используется pandas DataFrame city_pop и отбор городов происходит на основе тех же порогов, но с использованием сравнений "<" и ">=". Стоит проверить, что обе функции используют одинаковые пороги и правила отбора.

    3. Индексация и обращение к данным: В функции GeoFeaturesEnricher.enrich_data используется индексация indices[0][0] для доступа к индексу ближайшего города, тогда как в функции calculate_nearest_distance используется indices[:, 0]. Хотя это должно быть эквивалентно, но стоит проверить, что индексация работает правильно.

    4. Обработка исключений: В функции GeoFeaturesEnricher.enrich_data есть блок try-except, который в случае исключения использует переборный алгоритм для расчета расстояний. Если исключение происходит, это может привести к различиям в результатах.

    Чтобы найти причину, можно:

    • проверить код на наличие различий в расчете расстояний, отборе городов и индексации;
    • сравнить координаты и расстояния, используемые в обеих функциях;
    • добавить больше логов или отладочной информации, чтобы понять, как данные обрабатываются в обеих функциях.

    Если проблема все еще не найдена, можно предоставить больше информации о данных и результатах, чтобы я мог помочь вам дальше.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.