Skip to content
TheChatArchiveThe Chat Archive
mai-1-previewHugging 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. Assistant

    Основные причины расхождений в значениях dist_to_small_city между первой (GeoFeaturesEnricher.enrich_data) и второй (calculate_nearest_distance) функциями, даже при одинаковом входном данных:

    1. Разная логика обработки ошибок в KDTree:

    • Первая функция:
      • Использует try-except блок для small_cities. Если при обращении к KDTree возникает ошибка (например, из-за проблем с размерностью данных или внутренних ошибок библиотеки), происходит фолбек на переборный метод.
      • В переборном методе рассчитывается расстояние по haversine для всех городов типа small, что гарантирует нахождение истинного ближайшего города по геодезическому расстоянию.
      • Код:
        try:
            # Использует KDTree
        except Exception:
            # Перебирает все города small_cities и вычисляет min haversine
        
    • Вторая функция:
      • Всегда использует только KDTree без обработки ошибок. Если KDTree возвращает некорректный индекс (например, при пустом массиве или проблемах с запросом), результат будет неопределённым (например, NaN или случайное значение).
      • Нет механизма переключения на переборный метод.

    Почему это важно для small_cities?
    Если в данных для small_cities есть неточности (например, дубликаты, выбросы или проблемы с типами), KDTree может дать сбой. Первая функция в этом случае переключается на точный перебор, вторая — нет. Это ведёт к расхождениям.


    2. Разные метрики для поиска ближайшего города:

    • Обе функции используют KDTree с метрикой euclidean (евклидово расстояние в градусах).
    • Но:
      • В первой функции (в try-except блоке) после KDTree всегда вычисляется уточняющее расстояние по haversine для найденного города.
      • Во второй функции расстояние по haversine вычисляется только для кандидата, найденного KDTree, без проверки других городов.
    • Проблема:
      Евклидово расстояние в градусах не эквивалентно геодезическому расстоянию (особенно для больших углов). Город, ближайший по евклидовой метрике, может быть не самым близким по haversine.
      • Первая функция (в переборном режиме) находит истинного ближайшего по haversine.
      • Вторая функция всегда использует кандидата от KDTree, что может быть неточно.

    3. Разное округление результатов:

    • Первая функция:
      • Округляет результат haversine до 6 знаков после запятой:
        dist = round(dist, 6).
    • Вторая функция:
      • Не округляет результаты:
        df[f'dist_to_{city_type}_city'] = distances.
    • Эффект:
      Даже если города идентичны, значения могут визуально различаться из-за плавающей точки (хотя расхождения должны быть в пределах 1e-6 км).

    4. Разный состав данных для small_cities:

    Убедитесь, что списки городов для small_cities в обеих функциях полностью идентичны:

    • В первой функции:
      small_cities — список объектов CityCoords, отфильтрованных по условию city_population < MIDDLE_CITY_THRESHOLD (75000).
    • Во второй функции:
      small_cities — срез датафрейма city_pop по условию (city_population < 75000).
    • Потенциальные проблемы:
      • Если city_population содержит NaN, города могут включаться в small_cities только в одной из функций (в первой — через else, во второй — условие NaN < 75000 даст False в pandas).
      • Порядок городов в массивах для KDTree может влиять на индексацию (хотя в целом не должен).

    5. Обработка пустого списка городов:

    • Первая функция:
      Проверяет len(cls._city_data_by_type[city_type]) > 0 перед использованием KDTree. Если городов нет, поле не заполняется (None).
    • Вторая функция:
      Не проверяет пустоту city_df. Если city_coords пуст, KDTree вызовет ошибку ValueError (не обработана), и весь расчет для small_cities может завершиться с ошибкой (результат будет NaN или отсутствовать).

    Рекомендации по устранению:

    1. Логирование ошибок в первой функции:
      Добавьте детализацию в except Exception для small_cities, чтобы понять, почему возникает переключение на переборный метод:
      except Exception as e:
          # Логировать ошибку: type(e), traceback.format_exc()
          # Затем выполнять переборный метод
      
    2. Визуализация расхождений:
      Для примера дома с расхождениями:
      • Выведите город, найденный первой функцией (в try и except блоках).
      • Выведите город, найденный второй функцией.
      • Рассчитайте haversine расстояние вручную для обоих кандидатов.
    3. Синхронизируйте данные:
      Убедитесь, что city_coords и city_pop содержат одинаковые города (без NaN в населении).
    4. Стандартизируйте округление:
      Округляйте результаты в обеих функциях до одинакового числа знаков.
    5. Добавьте обработку ошибок во вторую функцию:
      Если city_df пуст, пропускайте расчет или возвращайте NaN явно.

    Если расхождения сохраняются, предоставьте примеры входных данных и лог ошибок для дальнейшей диагностики.

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