From 29715784127ed76c1e4b68a6f23cf76ad22c2d73 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Sun, 22 Jun 2025 00:16:43 -0400 Subject: [PATCH 01/24] chore: basic structure of the backend --- .github/workflows/ci.yml | 0 Dockerfile | 0 alembic/env.py | 0 app/main.py | 0 docker-compose.yml | 0 requirements.txt | 0 6 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 .github/workflows/ci.yml create mode 100644 Dockerfile create mode 100644 alembic/env.py create mode 100644 app/main.py create mode 100644 docker-compose.yml create mode 100644 requirements.txt diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..e69de29 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..e69de29 diff --git a/alembic/env.py b/alembic/env.py new file mode 100644 index 0000000..e69de29 diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..e69de29 diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..e69de29 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..e69de29 From fb99ef4d5f8e7b883bad599d2369ee159f8ea756 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Sun, 22 Jun 2025 00:39:57 -0400 Subject: [PATCH 02/24] chore: add requirements, Dockerfile, docker-compose, .env.example --- .env.example | 2 ++ Dockerfile | 14 ++++++++++++++ docker-compose.yml | 28 ++++++++++++++++++++++++++++ requirements.txt | 10 ++++++++++ 4 files changed, 54 insertions(+) create mode 100644 .env.example diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..75d9a2b --- /dev/null +++ b/.env.example @@ -0,0 +1,2 @@ +DATABASE_URL=postgresql://devuser:devpass@db:5432/devtest_db +ENV=development \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index e69de29..b048e22 100644 --- a/Dockerfile +++ b/Dockerfile @@ -0,0 +1,14 @@ +FROM python:3.13 + +WORKDIR /app + +RUN apt-get update && apt-get install -y build-essential + +COPY requirements.txt . + +RUN pip install --no-cache-dir -r requirements.txt + +COPY . . +EXPOSE 8000 + +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"] \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml index e69de29..1b4c38a 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -0,0 +1,28 @@ +version: "3.9" + +services: + db: + image: postgres:15 + environment: + POSTGRES_DB: devtest_db + POSTGRES_USER: devsaieh + POSTGRES_PASSWORD: saiehpass + ports: + - "5432:5432" + volumes: + - pgdata:/var/lib/postgresql/data + web: + build: . + command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload + volumes: + - .:/app + ports: + - "8000:8000" + depends_on: + - db + environment: + DATABASE_URL: postgresql://devuser:devpass@db:5432/devtest_db + ENV: development + +volumes: + pgdata: \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index e69de29..2b1de23 100644 --- a/requirements.txt +++ b/requirements.txt @@ -0,0 +1,10 @@ +fastapi +uvicorn[standard] +sqlalchemy +alembic +psycopg2-binary +pydantic +pytest +pytest-cov +requests +python-dotenv \ No newline at end of file From f5800006290a0e66d4c576bbd0a2540ff8909172 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Sun, 22 Jun 2025 00:42:38 -0400 Subject: [PATCH 03/24] feat: update python version --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index b048e22..b4e8744 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,4 @@ -FROM python:3.13 +FROM python:3.12-slim WORKDIR /app From 0e6a57c17238c2bad207e6fc7f47cf38cd011af0 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Sun, 22 Jun 2025 01:13:09 -0400 Subject: [PATCH 04/24] feat: update docker-compose.yml --- docker-compose.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docker-compose.yml b/docker-compose.yml index 1b4c38a..409dddf 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -8,7 +8,7 @@ services: POSTGRES_USER: devsaieh POSTGRES_PASSWORD: saiehpass ports: - - "5432:5432" + - "5433:5432" volumes: - pgdata:/var/lib/postgresql/data web: @@ -21,7 +21,7 @@ services: depends_on: - db environment: - DATABASE_URL: postgresql://devuser:devpass@db:5432/devtest_db + DATABASE_URL: postgresql://devsaieh:saiehpass@db:5432/devtest_db ENV: development volumes: From 46ec24f54061a8fa6af0c22afba69e17fa2aa5b4 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Sun, 22 Jun 2025 01:13:58 -0400 Subject: [PATCH 05/24] chore: add .gitignore --- .gitignore | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..adfc95e --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +__pycache__/ +*.pyc + +docker-compose.override.yml + +pgdata/ + +alembic/versions/ From 679a2cf1b230af75f2edc13c6b7a80f9b58c1424 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 12:29:19 -0400 Subject: [PATCH 06/24] feat: changes in initial setup --- .env.example | 2 +- Dockerfile | 2 +- docker-compose.yml | 2 -- requirements.txt | 4 +++- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.env.example b/.env.example index 75d9a2b..5962082 100644 --- a/.env.example +++ b/.env.example @@ -1,2 +1,2 @@ -DATABASE_URL=postgresql://devuser:devpass@db:5432/devtest_db +DATABASE_URL=postgresql://devsaieh:saiehpass@localhost:5433/devtest_db ENV=development \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index b4e8744..d3e2334 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,6 +1,6 @@ FROM python:3.12-slim -WORKDIR /app +WORKDIR /DEVTEST RUN apt-get update && apt-get install -y build-essential diff --git a/docker-compose.yml b/docker-compose.yml index 409dddf..79d64b5 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -1,5 +1,3 @@ -version: "3.9" - services: db: image: postgres:15 diff --git a/requirements.txt b/requirements.txt index 2b1de23..1bf0f61 100644 --- a/requirements.txt +++ b/requirements.txt @@ -7,4 +7,6 @@ pydantic pytest pytest-cov requests -python-dotenv \ No newline at end of file +python-dotenv +psycopg2-binary +httpx \ No newline at end of file From 39f02972146c981792da46fb6cbbbddd2ccd7482 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 12:46:59 -0400 Subject: [PATCH 07/24] chore: added Alembic migrations --- alembic.ini | 116 +++++++++++++++++++++++++++++++++++++++++ alembic/README | 1 + alembic/env.py | 82 +++++++++++++++++++++++++++++ alembic/script.py.mako | 26 +++++++++ makemigrations.sh | 19 +++++++ 5 files changed, 244 insertions(+) create mode 100644 alembic.ini create mode 100644 alembic/README create mode 100644 alembic/script.py.mako create mode 100755 makemigrations.sh diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 0000000..41f54ed --- /dev/null +++ b/alembic.ini @@ -0,0 +1,116 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts +script_location = alembic + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. +prepend_sys_path = . + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the python>=3.9 or backports.zoneinfo library. +# Any required deps can installed by adding `alembic[tz]` to the pip requirements +# string value is passed to ZoneInfo() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the +# "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to alembic/versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "version_path_separator" below. +# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions + +# version path separator; As mentioned above, this is the character used to split +# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep. +# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas. +# Valid values for version_path_separator are: +# +# version_path_separator = : +# version_path_separator = ; +# version_path_separator = space +version_path_separator = os # Use os.pathsep. Default configuration used for new projects. + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +sqlalchemy.url = postgresql://devsaieh:saiehpass@db:5432/devtest_db + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the exec runner, execute a binary +# hooks = ruff +# ruff.type = exec +# ruff.executable = %(here)s/.venv/bin/ruff +# ruff.options = --fix REVISION_SCRIPT_FILENAME + +# Logging configuration +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARN +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARN +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/alembic/README b/alembic/README new file mode 100644 index 0000000..98e4f9c --- /dev/null +++ b/alembic/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/alembic/env.py b/alembic/env.py index e69de29..6ff7389 100644 --- a/alembic/env.py +++ b/alembic/env.py @@ -0,0 +1,82 @@ +from logging.config import fileConfig + +from sqlalchemy import engine_from_config +from sqlalchemy import pool + +from alembic import context + +# this is the Alembic Config object, which provides +# access to the values within the .ini file in use. +config = context.config + +# Interpret the config file for Python logging. +# This line sets up loggers basically. +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +# add your model's MetaData object here +# for 'autogenerate' support +# from myapp import mymodel +# target_metadata = mymodel.Base.metadata +# IMPORTA Base desde donde defines tus modelos +from app.db.models import Base +# LÍNEA CLAVE: +target_metadata = Base.metadata + + +# other values from the config, defined by the needs of env.py, +# can be acquired: +# my_important_option = config.get_main_option("my_important_option") +# ... etc. + + +def run_migrations_offline() -> None: + """Run migrations in 'offline' mode. + + This configures the context with just a URL + and not an Engine, though an Engine is acceptable + here as well. By skipping the Engine creation + we don't even need a DBAPI to be available. + + Calls to context.execute() here emit the given string to the + script output. + + """ + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + + with context.begin_transaction(): + context.run_migrations() + + +def run_migrations_online() -> None: + """Run migrations in 'online' mode. + + In this scenario we need to create an Engine + and associate a connection with the context. + + """ + connectable = engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + + with connectable.connect() as connection: + context.configure( + connection=connection, target_metadata=target_metadata + ) + + with context.begin_transaction(): + context.run_migrations() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/alembic/script.py.mako b/alembic/script.py.mako new file mode 100644 index 0000000..fbc4b07 --- /dev/null +++ b/alembic/script.py.mako @@ -0,0 +1,26 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/makemigrations.sh b/makemigrations.sh new file mode 100755 index 0000000..8aff1e4 --- /dev/null +++ b/makemigrations.sh @@ -0,0 +1,19 @@ +set -e + +MSG=$1 + +if [ -z "$MSG" ]; then + echo "❌ Pass a migration message as an argument:" + echo "./makemigrations.sh \"mensaje de migración\"" + exit 1 +fi + +echo "Generating migration with Alembic in the container..." + +docker compose exec web alembic revision --autogenerate -m "$MSG" + +echo "Applying migration to DB..." +docker compose exec web alembic upgrade head + +echo "Migration Created!!" + From f0c683026c01e6b96802e5c206bcebdee5a145b0 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 13:29:12 -0400 Subject: [PATCH 08/24] feat: add DB models, Pydantic schemas, services logic and endpoints --- app/api/v1/endpoints/routes_demand.py | 67 ++++++++++++++++++++++++++ app/api/v1/endpoints/routes_resting.py | 63 ++++++++++++++++++++++++ app/db/db.py | 16 ++++++ app/db/models.py | 25 ++++++++++ app/main.py | 7 +++ app/schemas/demand.py | 27 +++++++++++ app/schemas/resting_period.py | 18 +++++++ app/services/data_utils.py | 44 +++++++++++++++++ 8 files changed, 267 insertions(+) create mode 100644 app/api/v1/endpoints/routes_demand.py create mode 100644 app/api/v1/endpoints/routes_resting.py create mode 100644 app/db/db.py create mode 100644 app/db/models.py create mode 100644 app/schemas/demand.py create mode 100644 app/schemas/resting_period.py create mode 100644 app/services/data_utils.py diff --git a/app/api/v1/endpoints/routes_demand.py b/app/api/v1/endpoints/routes_demand.py new file mode 100644 index 0000000..dbdb1e3 --- /dev/null +++ b/app/api/v1/endpoints/routes_demand.py @@ -0,0 +1,67 @@ +""" +Endpoints para manejar las demandas (llamadas) del ascensor. + +Incluye lógica de negocio que cierra automáticamente el último resting_period abierto +para el ascensor cuando se recibe una nueva demanda, y validaciones realistas de dominio. + +Decisión de diseño: validamos rango de piso para evitar datos corruptos y reflejar la realidad física del edificio. +""" + +from fastapi import APIRouter, Depends, HTTPException +from sqlalchemy.orm import Session +from app.schemas.demand import DemandCreate, DemandRead +from app.db.models import Demand, RestingPeriod +from app.db.db import get_db +from datetime import datetime, timezone + +router = APIRouter() + +# Defino el rango de pisos permitido. TODO: parametrizar esto según configuración por edificio. +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +@router.post("/demands/", response_model=DemandRead) +def create_demand(demand: DemandCreate, db: Session = Depends(get_db)): + """ + Registra una nueva demanda de ascensor. + - Valida que el piso esté en rango permitido. + - Cierra el último resting_period abierto (sin resting_end) para el ascensor, si existe. + """ + # Validación de piso: no se permiten pisos fuera de rango (ejemplo: sótanos o pisos inexistentes). + if demand.destination_floor < MIN_FLOOR or demand.destination_floor > MAX_FLOOR: + raise HTTPException( + status_code=400, + detail=f"El piso destino debe estar entre {MIN_FLOOR} y {MAX_FLOOR}." + ) + + # Al registrar una demanda, cerramos automáticamente el resting actual (idle) si existe. + last_resting = db.query(RestingPeriod).filter( + RestingPeriod.elevator_id == demand.elevator_id, + RestingPeriod.resting_end.is_(None) + ).order_by(RestingPeriod.resting_start.desc()).first() + + if last_resting: + # Usamos el mismo timestamp de la demanda para cerrar el periodo idle. + last_resting.resting_end = demand.timestamp_called or datetime.now(timezone.utc) + db.add(last_resting) + # Comentario: Esto ayuda a mantener coherencia temporal entre resting y demanda. + + db_demand = Demand( + elevator_id=demand.elevator_id, + floor=demand.floor, + destination_floor=demand.destination_floor, # NUEVO + timestamp_called=demand.timestamp_called or datetime.now(timezone.utc) + ) + + db.add(db_demand) + db.commit() + db.refresh(db_demand) + return db_demand + +@router.get("/demands/", response_model=list[DemandRead]) +def list_demands(db: Session = Depends(get_db)): + """ + Lista todas las demandas registradas. + Pensado para debug y análisis histórico. + """ + return db.query(Demand).all() diff --git a/app/api/v1/endpoints/routes_resting.py b/app/api/v1/endpoints/routes_resting.py new file mode 100644 index 0000000..cc146df --- /dev/null +++ b/app/api/v1/endpoints/routes_resting.py @@ -0,0 +1,63 @@ +""" +Endpoints para registrar periodos de descanso (idle) del ascensor. + +Incluye validaciones realistas de dominio: +- El piso debe estar dentro del rango permitido. +- El periodo de descanso no puede finalizar antes de iniciar. + +Decisión: Mantener los datos limpios facilita el futuro análisis y entrenamiento de modelos ML. +""" + +from fastapi import APIRouter, Depends, HTTPException +from sqlalchemy.orm import Session +from app.schemas.resting_period import RestingPeriodCreate, RestingPeriodRead +from app.db.models import RestingPeriod +from app.db.db import get_db +from datetime import datetime, timezone + +router = APIRouter() + +# Rango de pisos permitido para este edificio (igual que en demandas). +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +@router.post("/resting_periods/", response_model=RestingPeriodRead) +def create_resting_period(period: RestingPeriodCreate, db: Session = Depends(get_db)): + """ + Registra un periodo de descanso del ascensor. + - Valida rango de piso. + - Valida coherencia temporal (resting_end >= resting_start). + """ + if period.floor < MIN_FLOOR or period.floor > MAX_FLOOR: + raise HTTPException( + status_code=400, + detail=f"El piso debe estar entre {MIN_FLOOR} y {MAX_FLOOR}." + ) + # Si se ingresa resting_end, debe ser igual o posterior a resting_start (o a ahora si no se da inicio). + resting_start = period.resting_start or datetime.now(timezone.utc) + if period.resting_end and period.resting_end < resting_start: + raise HTTPException( + status_code=400, + detail="El final del periodo de descanso no puede ser anterior al inicio." + ) + db_period = RestingPeriod( + elevator_id=period.elevator_id, + floor=period.floor, + resting_start=resting_start, + resting_end=period.resting_end + ) + db.add(db_period) + db.commit() + db.refresh(db_period) + return db_period + +@router.get("/resting_periods/", response_model=list[RestingPeriodRead]) +def list_resting_periods(db: Session = Depends(get_db)): + """ + Lista todos los periodos de descanso registrados. + Esto es útil para análisis y debugging del flujo del ascensor. + """ + return db.query(RestingPeriod).all() + +# NOTA: En sistemas reales, sería interesante agregar endpoint PATCH para cerrar un periodo idle abierto cuando el ascensor recibe una demanda. +# TODO: Agregar validación para evitar superposición de periodos resting abiertos para el mismo ascensor. diff --git a/app/db/db.py b/app/db/db.py new file mode 100644 index 0000000..eecabaf --- /dev/null +++ b/app/db/db.py @@ -0,0 +1,16 @@ +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from sqlalchemy.orm import declarative_base +import os + +DATABASE_URL = os.environ.get("DATABASE_URL") or "postgresql://devsaieh:saiehpass@db:5432/devtest_db" +engine = create_engine(DATABASE_URL) +SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) +Base = declarative_base() + +def get_db(): + db = SessionLocal() + try: + yield db + finally: + db.close() diff --git a/app/db/models.py b/app/db/models.py new file mode 100644 index 0000000..f6983b7 --- /dev/null +++ b/app/db/models.py @@ -0,0 +1,25 @@ +# Modelos para registrar llamadas y periodos de descanso del ascensor. +# Notar: consideré que elevator_id sea opcional por ahora, pero si el sistema escala a varios ascensores debe hacerse obligatorio. +# Si en el futuro se modela la ocupación real del ascensor (número de personas), se podría agregar ese campo aquí. + +from sqlalchemy import Column, Integer, DateTime +from sqlalchemy.orm import declarative_base +from datetime import datetime, timezone + +Base = declarative_base() + +class Demand(Base): + __tablename__ = "demand" + id = Column(Integer, primary_key=True, index=True) + elevator_id = Column(Integer, index=True) + floor = Column(Integer, nullable=False) # Piso desde donde se llama + destination_floor = Column(Integer, nullable=False) # Piso al que quiere ir el usuario + timestamp_called = Column(DateTime, default=datetime.now(timezone.utc), index=True) + +class RestingPeriod(Base): + __tablename__ = "resting_period" + id = Column(Integer, primary_key=True, index=True) + elevator_id = Column(Integer, index=True) + floor = Column(Integer, nullable=False) + resting_start = Column(DateTime, default=datetime.now(timezone.utc), index=True) + resting_end = Column(DateTime, nullable=True, index=True) diff --git a/app/main.py b/app/main.py index e69de29..f907073 100644 --- a/app/main.py +++ b/app/main.py @@ -0,0 +1,7 @@ +from fastapi import FastAPI +from app.api.v1.endpoints import routes_demand, routes_resting + +app = FastAPI() + +app.include_router(routes_demand.router) +app.include_router(routes_resting.router) diff --git a/app/schemas/demand.py b/app/schemas/demand.py new file mode 100644 index 0000000..66fbe79 --- /dev/null +++ b/app/schemas/demand.py @@ -0,0 +1,27 @@ +""" +Schemas para Demandas de Ascensor. + +Estos modelos representan la estructura de los datos relacionados con las llamadas (demandas) al ascensor. +Pensé en dejar elevator_id como opcional para facilitar el desarrollo, pero en caso de escalar a múltiples ascensores debería volverse obligatorio. +""" + +from pydantic import BaseModel, Field, ConfigDict +from datetime import datetime +from typing import Optional + +class DemandBase(BaseModel): + floor: int = Field(..., description="Piso donde ocurre la llamada") + destination_floor: int = Field(..., description="Piso destino del usuario") + elevator_id: Optional[int] = Field(1, description="Identificador del ascensor (por defecto 1)") + +class DemandCreate(DemandBase): + timestamp_called: Optional[datetime] = Field( + None, + description="Momento en que se registró la demanda; se autocompleta si no se envía." + ) + +class DemandRead(DemandBase): + id: int + timestamp_called: datetime + + model_config = ConfigDict(from_attributes=True) diff --git a/app/schemas/resting_period.py b/app/schemas/resting_period.py new file mode 100644 index 0000000..b33316d --- /dev/null +++ b/app/schemas/resting_period.py @@ -0,0 +1,18 @@ +from pydantic import BaseModel, ConfigDict +from datetime import datetime +from typing import Optional + +class RestingPeriodBase(BaseModel): + floor: int + elevator_id: Optional[int] = 1 + +class RestingPeriodCreate(RestingPeriodBase): + resting_start: Optional[datetime] = None + resting_end: Optional[datetime] = None + +class RestingPeriodRead(RestingPeriodBase): + id: int + resting_start: datetime + resting_end: Optional[datetime] = None + + model_config = ConfigDict(from_attributes=True) diff --git a/app/services/data_utils.py b/app/services/data_utils.py new file mode 100644 index 0000000..dfbff08 --- /dev/null +++ b/app/services/data_utils.py @@ -0,0 +1,44 @@ +""" +Funciones utilitarias para poblar la base de datos con datos artificiales realistas. +Se usan en scripts de testeo y generación de datos para ML. +Decidí crear estos helpers para no repetir lógica de negocio ni validar manualmente cada campo. +""" + +from app.db.models import Demand, RestingPeriod +from sqlalchemy.orm import Session +from datetime import datetime +from typing import Optional + +def create_resting_period(db: Session, elevator_id: int, floor: int, resting_start: datetime, resting_end: Optional[datetime]): + """ + Crea y guarda un periodo de descanso. + Validación extra podría añadirse aquí si cambian las reglas del dominio. + """ + rp = RestingPeriod( + elevator_id=elevator_id, + floor=floor, + resting_start=resting_start, + resting_end=resting_end, + ) + db.add(rp) + db.commit() + db.refresh(rp) + return rp + +def create_demand(db: Session, elevator_id: int, floor: int, timestamp_called: datetime): + """ + Crea y guarda una demanda (llamada de ascensor). + Esta función podría ampliarse en el futuro para cerrar resting_periods automáticamente. + """ + d = Demand( + elevator_id=elevator_id, + floor=floor, + timestamp_called=timestamp_called, + ) + db.add(d) + db.commit() + db.refresh(d) + return d + +# NOTA: Si cambian las reglas de negocio, agrega aquí validaciones globales. +# Ejemplo: rango de pisos, horarios restringidos, etc. From 38845682a89ee18201a19c2bc9e67f5eac6f07d7 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 13:36:46 -0400 Subject: [PATCH 09/24] feat: correct identation --- app/api/v1/endpoints/routes_demand.py | 7 ++----- app/api/v1/endpoints/routes_resting.py | 1 - 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/app/api/v1/endpoints/routes_demand.py b/app/api/v1/endpoints/routes_demand.py index dbdb1e3..099c5f4 100644 --- a/app/api/v1/endpoints/routes_demand.py +++ b/app/api/v1/endpoints/routes_demand.py @@ -4,7 +4,6 @@ Incluye lógica de negocio que cierra automáticamente el último resting_period abierto para el ascensor cuando se recibe una nueva demanda, y validaciones realistas de dominio. -Decisión de diseño: validamos rango de piso para evitar datos corruptos y reflejar la realidad física del edificio. """ from fastapi import APIRouter, Depends, HTTPException @@ -16,7 +15,7 @@ router = APIRouter() -# Defino el rango de pisos permitido. TODO: parametrizar esto según configuración por edificio. +# Defino el rango de pisos permitido. MIN_FLOOR = 1 MAX_FLOOR = 12 @@ -27,7 +26,6 @@ def create_demand(demand: DemandCreate, db: Session = Depends(get_db)): - Valida que el piso esté en rango permitido. - Cierra el último resting_period abierto (sin resting_end) para el ascensor, si existe. """ - # Validación de piso: no se permiten pisos fuera de rango (ejemplo: sótanos o pisos inexistentes). if demand.destination_floor < MIN_FLOOR or demand.destination_floor > MAX_FLOOR: raise HTTPException( status_code=400, @@ -44,12 +42,11 @@ def create_demand(demand: DemandCreate, db: Session = Depends(get_db)): # Usamos el mismo timestamp de la demanda para cerrar el periodo idle. last_resting.resting_end = demand.timestamp_called or datetime.now(timezone.utc) db.add(last_resting) - # Comentario: Esto ayuda a mantener coherencia temporal entre resting y demanda. db_demand = Demand( elevator_id=demand.elevator_id, floor=demand.floor, - destination_floor=demand.destination_floor, # NUEVO + destination_floor=demand.destination_floor, timestamp_called=demand.timestamp_called or datetime.now(timezone.utc) ) diff --git a/app/api/v1/endpoints/routes_resting.py b/app/api/v1/endpoints/routes_resting.py index cc146df..793c2c9 100644 --- a/app/api/v1/endpoints/routes_resting.py +++ b/app/api/v1/endpoints/routes_resting.py @@ -5,7 +5,6 @@ - El piso debe estar dentro del rango permitido. - El periodo de descanso no puede finalizar antes de iniciar. -Decisión: Mantener los datos limpios facilita el futuro análisis y entrenamiento de modelos ML. """ from fastapi import APIRouter, Depends, HTTPException From 62ce068a69448c91d2527795187227adef922daf Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 13:37:20 -0400 Subject: [PATCH 10/24] add destination_floor --- app/db/models.py | 6 +----- app/services/data_utils.py | 12 ++---------- 2 files changed, 3 insertions(+), 15 deletions(-) diff --git a/app/db/models.py b/app/db/models.py index f6983b7..d9430a4 100644 --- a/app/db/models.py +++ b/app/db/models.py @@ -1,7 +1,3 @@ -# Modelos para registrar llamadas y periodos de descanso del ascensor. -# Notar: consideré que elevator_id sea opcional por ahora, pero si el sistema escala a varios ascensores debe hacerse obligatorio. -# Si en el futuro se modela la ocupación real del ascensor (número de personas), se podría agregar ese campo aquí. - from sqlalchemy import Column, Integer, DateTime from sqlalchemy.orm import declarative_base from datetime import datetime, timezone @@ -11,7 +7,7 @@ class Demand(Base): __tablename__ = "demand" id = Column(Integer, primary_key=True, index=True) - elevator_id = Column(Integer, index=True) + elevator_id = Column(Integer, index=True) #por ahora solo un ascensor floor = Column(Integer, nullable=False) # Piso desde donde se llama destination_floor = Column(Integer, nullable=False) # Piso al que quiere ir el usuario timestamp_called = Column(DateTime, default=datetime.now(timezone.utc), index=True) diff --git a/app/services/data_utils.py b/app/services/data_utils.py index dfbff08..62ad68e 100644 --- a/app/services/data_utils.py +++ b/app/services/data_utils.py @@ -1,9 +1,3 @@ -""" -Funciones utilitarias para poblar la base de datos con datos artificiales realistas. -Se usan en scripts de testeo y generación de datos para ML. -Decidí crear estos helpers para no repetir lógica de negocio ni validar manualmente cada campo. -""" - from app.db.models import Demand, RestingPeriod from sqlalchemy.orm import Session from datetime import datetime @@ -25,7 +19,7 @@ def create_resting_period(db: Session, elevator_id: int, floor: int, resting_sta db.refresh(rp) return rp -def create_demand(db: Session, elevator_id: int, floor: int, timestamp_called: datetime): +def create_demand(db: Session, elevator_id: int, destination_floor: int, floor: int, timestamp_called: datetime): """ Crea y guarda una demanda (llamada de ascensor). Esta función podría ampliarse en el futuro para cerrar resting_periods automáticamente. @@ -33,12 +27,10 @@ def create_demand(db: Session, elevator_id: int, floor: int, timestamp_called: d d = Demand( elevator_id=elevator_id, floor=floor, + destination_floor=destination_floor, timestamp_called=timestamp_called, ) db.add(d) db.commit() db.refresh(d) return d - -# NOTA: Si cambian las reglas de negocio, agrega aquí validaciones globales. -# Ejemplo: rango de pisos, horarios restringidos, etc. From 3a32fd708f9b98fea00c4036f5a1397436a66569 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 14:27:18 -0400 Subject: [PATCH 11/24] feat: change routes --- alembic/env.py | 1 - docker-compose.yml | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/alembic/env.py b/alembic/env.py index 6ff7389..f3e3922 100644 --- a/alembic/env.py +++ b/alembic/env.py @@ -20,7 +20,6 @@ # target_metadata = mymodel.Base.metadata # IMPORTA Base desde donde defines tus modelos from app.db.models import Base -# LÍNEA CLAVE: target_metadata = Base.metadata diff --git a/docker-compose.yml b/docker-compose.yml index 79d64b5..4dee462 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -13,7 +13,7 @@ services: build: . command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload volumes: - - .:/app + - .:/DEVTEST ports: - "8000:8000" depends_on: From 4173e8c8f828c50b07f266993538d5df86bd4cf7 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 14:35:38 -0400 Subject: [PATCH 12/24] feat: add floor range --- app/api/v1/endpoints/routes_demand.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/app/api/v1/endpoints/routes_demand.py b/app/api/v1/endpoints/routes_demand.py index 099c5f4..2d57b4e 100644 --- a/app/api/v1/endpoints/routes_demand.py +++ b/app/api/v1/endpoints/routes_demand.py @@ -31,6 +31,11 @@ def create_demand(demand: DemandCreate, db: Session = Depends(get_db)): status_code=400, detail=f"El piso destino debe estar entre {MIN_FLOOR} y {MAX_FLOOR}." ) + if demand.floor < MIN_FLOOR or demand.floor > MAX_FLOOR: + raise HTTPException( + status_code=400, + detail=f"El piso debe estar entre {MIN_FLOOR} y {MAX_FLOOR}." + ) # Al registrar una demanda, cerramos automáticamente el resting actual (idle) si existe. last_resting = db.query(RestingPeriod).filter( From 8a761aad5be2b2ff5037e632c0051cb112fe0724 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 14:36:11 -0400 Subject: [PATCH 13/24] feat: add unitary tests --- app/tests/test_demands.py | 95 +++++++++++++++++++++++++++++++++++++++ app/tests/test_resting.py | 60 +++++++++++++++++++++++++ pytest.ini | 4 ++ runtests.sh | 4 ++ 4 files changed, 163 insertions(+) create mode 100644 app/tests/test_demands.py create mode 100644 app/tests/test_resting.py create mode 100644 pytest.ini create mode 100755 runtests.sh diff --git a/app/tests/test_demands.py b/app/tests/test_demands.py new file mode 100644 index 0000000..4240cfc --- /dev/null +++ b/app/tests/test_demands.py @@ -0,0 +1,95 @@ +""" +Tests para el endpoint de demandas (llamadas de ascensor). + +puntos a testear para este endpoint: +-Validacion de pisos posibles +-Validacion de piso destino +-Cierre automatico del resting_period +-Que las demandas sean guardadas en sistema +""" + +from fastapi.testclient import TestClient +from app.main import app + +client = TestClient(app) + +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +def test_create_demand_ok(): + """ + Prueba que se pueda crear una demanda en el piso mínimo permitido, con un destino válido. + """ + payload = { + "floor": MIN_FLOOR, + "destination_floor": MIN_FLOOR + 1 # Un destino válido distinto al origen + } + response = client.post("/demands/", json=payload) + assert response.status_code == 200 + data = response.json() + assert data["floor"] == MIN_FLOOR + assert data["destination_floor"] == MIN_FLOOR + 1 + assert "id" in data + assert "timestamp_called" in data + +def test_create_demand_out_of_range(): + """ + No debe aceptarse una demanda para un piso inexistente. + """ + payload = { + "floor": MAX_FLOOR + 1, + "destination_floor": MIN_FLOOR + } + response = client.post("/demands/", json=payload) + assert response.status_code == 400 + assert "El piso debe estar entre" in response.json()["detail"] + +def test_create_demand_negative_floor(): + """ + Caso borde: piso negativo. + """ + payload = { + "floor": -5, + "destination_floor": MIN_FLOOR + } + response = client.post("/demands/", json=payload) + assert response.status_code == 400 + +def test_create_demand_invalid_destination(): + """ + No debe aceptarse una demanda para un destino fuera de rango. + """ + payload = { + "floor": MIN_FLOOR, + "destination_floor": MAX_FLOOR + 1 + } + response = client.post("/demands/", json=payload) + assert response.status_code == 400 + assert "piso destino" in response.json()["detail"] + +def test_list_demands(): + """ + Comprueba que las demandas se acumulen en el sistema. + """ + client.post("/demands/", json={"floor": MIN_FLOOR, "destination_floor": MIN_FLOOR + 1}) + client.post("/demands/", json={"floor": MAX_FLOOR, "destination_floor": MIN_FLOOR}) + response = client.get("/demands/") + assert response.status_code == 200 + data = response.json() + assert isinstance(data, list) + # Al menos dos demandas deben haberse registrado. + assert len(data) >= 2 + +def test_resting_is_closed_on_demand(): + """ + Prueba que al crear una demanda se cierra automáticamente el último resting abierto. + """ + # Abrimos un resting_period manualmente. + client.post("/resting_periods/", json={"floor": MIN_FLOOR}) + # Ahora creamos una demanda, que debería cerrar el resting. + response = client.post("/demands/", json={"floor": MIN_FLOOR, "destination_floor": MIN_FLOOR + 1}) + assert response.status_code == 200 + # Revisamos que el último resting_period tenga resting_end no nulo. + response = client.get("/resting_periods/") + restings = response.json() + assert restings[-1]["resting_end"] is not None diff --git a/app/tests/test_resting.py b/app/tests/test_resting.py new file mode 100644 index 0000000..314b6fe --- /dev/null +++ b/app/tests/test_resting.py @@ -0,0 +1,60 @@ +""" +Tests para endpoint de periodos de descanso (resting_periods). + +Incluye validaciones de negocio y casos raros, simulando errores comunes de usuarios o carga manual. +""" + +from fastapi.testclient import TestClient +from app.main import app + +client = TestClient(app) + +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +def test_create_resting_ok(): + """ + Test simple: crear un resting_period válido en el piso más bajo. + """ + payload = {"floor": MIN_FLOOR} + response = client.post("/resting_periods/", json=payload) + assert response.status_code == 200 + data = response.json() + assert data["floor"] == MIN_FLOOR + assert "id" in data + +def test_create_resting_out_of_range(): + """ + No se debe aceptar un resting en un piso que no existe. + Suele pasar si hay un error en los sensores del sistema físico. + """ + payload = {"floor": MAX_FLOOR + 1} + response = client.post("/resting_periods/", json=payload) + assert response.status_code == 400 + +def test_create_resting_end_before_start(): + """ + Caso de error de ingreso manual: el tiempo de término no puede ser anterior al de inicio. + """ + from datetime import datetime, timedelta + start = datetime.now().isoformat() + end = (datetime.now() - timedelta(minutes=10)).isoformat() + payload = { + "floor": MIN_FLOOR, + "resting_start": start, + "resting_end": end + } + response = client.post("/resting_periods/", json=payload) + assert response.status_code == 400 + assert "no puede ser anterior" in response.json()["detail"] + +def test_list_restings(): + """ + Asegura que los periodos de descanso se almacenan correctamente y pueden ser consultados. + """ + client.post("/resting_periods/", json={"floor": MIN_FLOOR}) + response = client.get("/resting_periods/") + assert response.status_code == 200 + data = response.json() + assert isinstance(data, list) + assert len(data) >= 1 diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..22c84dc --- /dev/null +++ b/pytest.ini @@ -0,0 +1,4 @@ +[pytest] +testpaths = app/tests +python_files = test_*.py +addopts = --tb=short -p no:warnings \ No newline at end of file diff --git a/runtests.sh b/runtests.sh new file mode 100755 index 0000000..ce8c692 --- /dev/null +++ b/runtests.sh @@ -0,0 +1,4 @@ +set -e +echo "🧪 Ejecutando tests en: app/tests" +docker compose exec web bash -c "PYTHONPATH=/DEVTEST pytest app/tests" + From 00f869e70abf3a532e28d501327a33626ece146d Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Tue, 24 Jun 2025 14:47:57 -0400 Subject: [PATCH 14/24] feat: add a fake data generator to train the model --- app/ml/fake_data.py | 76 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 app/ml/fake_data.py diff --git a/app/ml/fake_data.py b/app/ml/fake_data.py new file mode 100644 index 0000000..be3a417 --- /dev/null +++ b/app/ml/fake_data.py @@ -0,0 +1,76 @@ +""" +Script para poblar la base con datos artificiales, simulando la lógica de uso real de un ascensor. + +- Más actividad en horario laboral. +- Descansos más largos en pisos intermedios. +- Llamadas simuladas según patrones horarios (mañana suben, tarde bajan). +- Usa helpers para mantener la lógica de negocio centralizada. + +Esto permite testear todo el pipeline y entrenar un futuro modelo ML. +""" +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from app.services.data_utils import create_resting_period, create_demand +from datetime import datetime, timedelta +import random +import os + +DATABASE_URL = os.environ.get("DATABASE_URL") or "postgresql://devsaieh:saiehpass@localhost:5433/devtest_db" +engine = create_engine(DATABASE_URL) +Session = sessionmaker(bind=engine) + +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +def random_resting_floor(hour): + if hour < 7 or hour > 20: + return MIN_FLOOR + return random.choice(range(2, MAX_FLOOR)) + +def random_demand(hour): + if 8 <= hour < 10: + return MIN_FLOOR, random.randint(2, MAX_FLOOR) + elif 17 <= hour < 19: + return random.randint(2, MAX_FLOOR), MIN_FLOOR + else: + piso_from = random.randint(MIN_FLOOR, MAX_FLOOR) + piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) + while piso_to == piso_from: + piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) + return piso_from, piso_to + +def generate_fake_data(days=5, seed=42): + random.seed(seed) + session = Session() + base_date = datetime.now().replace(hour=6, minute=0, second=0, microsecond=0) + for day in range(days): + curr_time = base_date + timedelta(days=day) + for i in range(10, 22): # Simula actividad diurna y vespertina + curr_hour = curr_time.replace(hour=i) + # 1. Registra resting_period + resting_floor = random_resting_floor(i) + resting_start = curr_hour + resting_end = curr_hour + timedelta(minutes=random.randint(2, 8)) + create_resting_period( + db=session, + elevator_id=1, + floor=resting_floor, + resting_start=resting_start, + resting_end=resting_end + ) + # 2. Registra 1-2 demandas luego del descanso + for _ in range(random.randint(1, 2)): + from_floor, to_floor = random_demand(i) + demand_time = resting_end + timedelta(minutes=random.randint(1, 5)) + create_demand( + db=session, + elevator_id=1, + floor=from_floor, + destination_floor=to_floor, + timestamp_called=demand_time + ) + session.close() + print(f"Datos artificiales generados para {days} días.") + +if __name__ == "__main__": + generate_fake_data(days=7) From 90a0cce4af282901b2e8862c06a590697a361fce Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 12:29:56 -0400 Subject: [PATCH 15/24] feat: add weekend logic --- app/ml/fake_data.py | 74 +++++++++++++++++++++++++++++++-------------- 1 file changed, 52 insertions(+), 22 deletions(-) diff --git a/app/ml/fake_data.py b/app/ml/fake_data.py index be3a417..1f5b85c 100644 --- a/app/ml/fake_data.py +++ b/app/ml/fake_data.py @@ -1,19 +1,10 @@ -""" -Script para poblar la base con datos artificiales, simulando la lógica de uso real de un ascensor. - -- Más actividad en horario laboral. -- Descansos más largos en pisos intermedios. -- Llamadas simuladas según patrones horarios (mañana suben, tarde bajan). -- Usa helpers para mantener la lógica de negocio centralizada. - -Esto permite testear todo el pipeline y entrenar un futuro modelo ML. -""" from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from app.services.data_utils import create_resting_period, create_demand from datetime import datetime, timedelta import random import os +import numpy as np DATABASE_URL = os.environ.get("DATABASE_URL") or "postgresql://devsaieh:saiehpass@localhost:5433/devtest_db" engine = create_engine(DATABASE_URL) @@ -22,12 +13,38 @@ MIN_FLOOR = 1 MAX_FLOOR = 12 -def random_resting_floor(hour): +def random_resting_floor(hour, is_weekend): + """ + En fines de semana, el ascensor descansa más tiempo en el lobby. + """ if hour < 7 or hour > 20: return MIN_FLOOR + if is_weekend: + return MIN_FLOOR if random.random() < 0.7 else random.choice(range(2, MAX_FLOOR)) + # Días de semana: intermedio return random.choice(range(2, MAX_FLOOR)) -def random_demand(hour): +def random_demand(hour, is_weekend): + """ + Días de semana: patrones normales. + Fines de semana: menos tráfico, más viajes entre pisos bajos. + """ + if is_weekend: + # Menos tráfico y la mayoría son entre pisos bajos. + if random.random() < 0.8: + piso_from = random.choice([MIN_FLOOR, 2, 3]) + piso_to = random.choice([MIN_FLOOR, 2, 3]) + while piso_to == piso_from: + piso_to = random.choice([MIN_FLOOR, 2, 3]) + return piso_from, piso_to + else: + piso_from = random.randint(MIN_FLOOR, MAX_FLOOR) + piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) + while piso_to == piso_from: + piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) + return piso_from, piso_to + + # Días de semana: patrón original if 8 <= hour < 10: return MIN_FLOOR, random.randint(2, MAX_FLOOR) elif 17 <= hour < 19: @@ -39,18 +56,26 @@ def random_demand(hour): piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) return piso_from, piso_to -def generate_fake_data(days=5, seed=42): +def generate_fake_data(days=7, seed=42): + """ + Genera datos artificiales para 'days' días seguidos, con fines de semana diferenciados. + """ random.seed(seed) + np.random.seed(seed) session = Session() base_date = datetime.now().replace(hour=6, minute=0, second=0, microsecond=0) for day in range(days): curr_time = base_date + timedelta(days=day) - for i in range(10, 22): # Simula actividad diurna y vespertina + weekday = curr_time.weekday() + is_weekend = weekday >= 5 # sábado=5, domingo=6 + + for i in range(10, 22): # 10:00 a 21:00 curr_hour = curr_time.replace(hour=i) - # 1. Registra resting_period - resting_floor = random_resting_floor(i) + # 1. Resting period + resting_floor = random_resting_floor(i, is_weekend) resting_start = curr_hour - resting_end = curr_hour + timedelta(minutes=random.randint(2, 8)) + resting_duration = random.randint(5, 14) if is_weekend else random.randint(2, 8) + resting_end = curr_hour + timedelta(minutes=resting_duration) create_resting_period( db=session, elevator_id=1, @@ -58,10 +83,15 @@ def generate_fake_data(days=5, seed=42): resting_start=resting_start, resting_end=resting_end ) - # 2. Registra 1-2 demandas luego del descanso - for _ in range(random.randint(1, 2)): - from_floor, to_floor = random_demand(i) - demand_time = resting_end + timedelta(minutes=random.randint(1, 5)) + # 2. Número de demandas menor en finde + n_demands = random.randint(0, 1) if is_weekend else random.randint(1, 2) + last_time = resting_end + for _ in range(n_demands): + from_floor, to_floor = random_demand(i, is_weekend) + # Tiempo entre descansos y demanda: exponencial (más realista) + minutes = int(np.random.exponential(scale=3)) + demand_time = last_time + timedelta(minutes=max(1, minutes)) + last_time = demand_time create_demand( db=session, elevator_id=1, @@ -73,4 +103,4 @@ def generate_fake_data(days=5, seed=42): print(f"Datos artificiales generados para {days} días.") if __name__ == "__main__": - generate_fake_data(days=7) + generate_fake_data(days=31) From 47cb73afc97e0b9f04bf45506f2a69a2217bc435 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 12:32:55 -0400 Subject: [PATCH 16/24] feat: eda of fake data --- ml/eda.ipynb | 711 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 711 insertions(+) create mode 100644 ml/eda.ipynb diff --git a/ml/eda.ipynb b/ml/eda.ipynb new file mode 100644 index 0000000..a40715e --- /dev/null +++ b/ml/eda.ipynb @@ -0,0 +1,711 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dcb41031", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c1f8b06a", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from sqlalchemy import create_engine\n", + "from datetime import datetime\n", + "\n", + "# Configuración visual\n", + "sns.set(style=\"whitegrid\")\n", + "plt.rcParams[\"figure.figsize\"] = (12, 6)\n", + "\n", + "# Conexión a la base de datos local\n", + "DATABASE_URL = \"postgresql://devsaieh:saiehpass@localhost:5433/devtest_db\"\n", + "engine = create_engine(DATABASE_URL)\n" + ] + }, + { + "cell_type": "markdown", + "id": "f9b2d2c9", + "metadata": {}, + "source": [ + "# Carga de Datos" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "4cfbff17", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idelevator_idfloordestination_floortimestamp_called
011432025-06-24 10:03:00
12111122025-06-24 10:07:00
231122025-06-24 11:08:00
341492025-06-24 11:11:00
45112112025-06-24 12:11:00
\n", + "
" + ], + "text/plain": [ + " id elevator_id floor destination_floor timestamp_called\n", + "0 1 1 4 3 2025-06-24 10:03:00\n", + "1 2 1 11 12 2025-06-24 10:07:00\n", + "2 3 1 1 2 2025-06-24 11:08:00\n", + "3 4 1 4 9 2025-06-24 11:11:00\n", + "4 5 1 12 11 2025-06-24 12:11:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idelevator_idfloorresting_startresting_end
01132025-06-24 10:00:002025-06-24 10:02:00
12132025-06-24 11:00:002025-06-24 11:06:00
23122025-06-24 12:00:002025-06-24 12:06:00
34182025-06-24 13:00:002025-06-24 13:03:00
45172025-06-24 14:00:002025-06-24 14:04:00
\n", + "
" + ], + "text/plain": [ + " id elevator_id floor resting_start resting_end\n", + "0 1 1 3 2025-06-24 10:00:00 2025-06-24 10:02:00\n", + "1 2 1 3 2025-06-24 11:00:00 2025-06-24 11:06:00\n", + "2 3 1 2 2025-06-24 12:00:00 2025-06-24 12:06:00\n", + "3 4 1 8 2025-06-24 13:00:00 2025-06-24 13:03:00\n", + "4 5 1 7 2025-06-24 14:00:00 2025-06-24 14:04:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "demand_df = pd.read_sql(\"SELECT * FROM demand\", engine)\n", + "resting_df = pd.read_sql(\"SELECT * FROM resting_period\", engine)\n", + "\n", + "# Conversión de fechas\n", + "demand_df[\"timestamp_called\"] = pd.to_datetime(demand_df[\"timestamp_called\"])\n", + "resting_df[\"resting_start\"] = pd.to_datetime(resting_df[\"resting_start\"])\n", + "resting_df[\"resting_end\"] = pd.to_datetime(resting_df[\"resting_end\"])\n", + "\n", + "# Vista inicial\n", + "display(demand_df.head())\n", + "display(resting_df.head())" + ] + }, + { + "cell_type": "markdown", + "id": "e0515f71", + "metadata": {}, + "source": [ + "# Limpieza" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "76f3c9ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Demand nulls:\n", + " id 0\n", + "elevator_id 0\n", + "floor 0\n", + "destination_floor 0\n", + "timestamp_called 0\n", + "dtype: int64\n", + "Resting nulls:\n", + " id 0\n", + "elevator_id 0\n", + "floor 0\n", + "resting_start 0\n", + "resting_end 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# Revisar nulos\n", + "print(\"Demand nulls:\\n\", demand_df.isnull().sum())\n", + "print(\"Resting nulls:\\n\", resting_df.isnull().sum())\n", + "\n", + "# Quitar nulos evidentes (por ahora ignoramos resting_end nulos porque pueden ser resting abiertos)\n", + "resting_df = resting_df.dropna(subset=[\"resting_start\"])\n", + "demand_df = demand_df.dropna(subset=[\"timestamp_called\"])\n", + "\n", + "# Reset index por si es necesario\n", + "demand_df = demand_df.reset_index(drop=True)\n", + "resting_df = resting_df.reset_index(drop=True)\n" + ] + }, + { + "cell_type": "markdown", + "id": "30baba9c", + "metadata": {}, + "source": [ + "# Analisis por hora" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "88ceac61", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_13054/1710264984.py:2: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.countplot(x=\"hour\", data=demand_df, palette=\"crest\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "demand_df[\"hour\"] = demand_df[\"timestamp_called\"].dt.hour\n", + "sns.countplot(x=\"hour\", data=demand_df, palette=\"crest\")\n", + "plt.title(\"Demandas por hora\")\n", + "plt.xlabel(\"Hora del día\")\n", + "plt.ylabel(\"Número de llamadas\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "ac0c3b1c", + "metadata": {}, + "source": [ + "# Demanda por piso" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "b6a151c8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(resting_df[\"floor\"], bins=range(1, 14), discrete=True, color=\"salmon\")\n", + "plt.title(\"Pisos donde el ascensor descansa\")\n", + "plt.xlabel(\"Piso\")\n", + "plt.ylabel(\"Frecuencia\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "08ae251e", + "metadata": {}, + "source": [ + "# Duracion de descansos" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "53694334", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Número de pisos\n", + "MIN_FLOOR = demand_df[\"floor\"].min()\n", + "MAX_FLOOR = demand_df[\"floor\"].max()\n", + "\n", + "# Conteo por hora y piso\n", + "calls_by_hour_floor = demand_df.groupby([\"hour\", \"floor\"]).size().unstack(fill_value=0)\n", + "calls_by_hour_floor\n", + "\n", + "# Probabilidad de que la siguiente llamada sea en cada piso para cada hora\n", + "prob_by_hour_floor = calls_by_hour_floor.div(calls_by_hour_floor.sum(axis=1), axis=0)\n", + "prob_by_hour_floor = prob_by_hour_floor.fillna(0)\n", + "prob_by_hour_floor.head(10)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(12,6))\n", + "prob_by_hour_floor.plot(kind=\"bar\", stacked=True, colormap=\"tab20\", width=1)\n", + "plt.title(\"Distribución de probabilidad de llamadas por piso para cada hora\")\n", + "plt.ylabel(\"Probabilidad\")\n", + "plt.xlabel(\"Hora del día\")\n", + "plt.legend(title=\"Piso\", bbox_to_anchor=(1,1))\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f9ed7b4d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Cálculo de duración en minutos\n", + "resting_df[\"duration_min\"] = (\n", + " resting_df[\"resting_end\"] - resting_df[\"resting_start\"]\n", + ").dt.total_seconds() / 60\n", + "\n", + "sns.histplot(resting_df[\"duration_min\"], bins=20, color=\"purple\")\n", + "plt.title(\"Duración de descansos (en minutos)\")\n", + "plt.xlabel(\"Minutos\")\n", + "plt.ylabel(\"Cantidad\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "470ad7b9", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "def expected_distance(prob_vector, resting_floor):\n", + " return np.sum([prob * abs(resting_floor - floor) for floor, prob in enumerate(prob_vector, start=MIN_FLOOR)])" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "64595d23", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hourbest_resting_floorexpected_distance
01062.222222
11143.090909
21253.444444
31342.769231
41442.555556
51572.300000
61662.400000
717103.000000
81893.100000
91972.700000
102063.000000
112162.700000
\n", + "
" + ], + "text/plain": [ + " hour best_resting_floor expected_distance\n", + "0 10 6 2.222222\n", + "1 11 4 3.090909\n", + "2 12 5 3.444444\n", + "3 13 4 2.769231\n", + "4 14 4 2.555556\n", + "5 15 7 2.300000\n", + "6 16 6 2.400000\n", + "7 17 10 3.000000\n", + "8 18 9 3.100000\n", + "9 19 7 2.700000\n", + "10 20 6 3.000000\n", + "11 21 6 2.700000" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_resting_per_hour = []\n", + "for hour in prob_by_hour_floor.index:\n", + " probs = prob_by_hour_floor.loc[hour].values\n", + " min_dist = float('inf')\n", + " best_floor = None\n", + " for resting_floor in range(MIN_FLOOR, MAX_FLOOR+1):\n", + " dist = expected_distance(probs, resting_floor)\n", + " if dist < min_dist:\n", + " min_dist = dist\n", + " best_floor = resting_floor\n", + " best_resting_per_hour.append({\"hour\": hour, \"best_resting_floor\": best_floor, \"expected_distance\": min_dist})\n", + "\n", + "resting_df_optimal = pd.DataFrame(best_resting_per_hour)\n", + "resting_df_optimal\n" + ] + }, + { + "cell_type": "markdown", + "id": "2ddd1d16", + "metadata": {}, + "source": [ + "# Variables para ML" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "47277bae", + "metadata": {}, + "outputs": [], + "source": [ + "# Demand: extraer features útiles\n", + "demand_df[\"weekday\"] = demand_df[\"timestamp_called\"].dt.weekday\n", + "demand_df[\"hour\"] = demand_df[\"timestamp_called\"].dt.hour\n", + "demand_df[\"day\"] = demand_df[\"timestamp_called\"].dt.date\n", + "\n", + "# Etiqueta: ¿ocurre entre 8-10 AM o 17-19 PM?\n", + "demand_df[\"peak_hours\"] = demand_df[\"hour\"].apply(\n", + " lambda h: 1 if (8 <= h < 10) or (17 <= h < 19) else 0\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5ff5141b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['id', 'elevator_id', 'floor', 'timestamp_called', 'hour', 'weekday',\n", + " 'day', 'peak_hours'],\n", + " dtype='object')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "demand_df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1499e6df", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['id', 'elevator_id', 'floor', 'resting_start', 'resting_end',\n", + " 'duration_min'],\n", + " dtype='object')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resting_df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37562577", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".env_dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From e4419719ddf42c7a059029b7faaeea7651fcb853 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 13:20:54 -0400 Subject: [PATCH 17/24] feat: delete file --- .github/workflows/ci.yml | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml deleted file mode 100644 index e69de29..0000000 From 003a9f51735f252df9f9855e50d448bfa74443dd Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 13:21:18 -0400 Subject: [PATCH 18/24] feat:edit route --- ml/eda.ipynb | 792 +++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 647 insertions(+), 145 deletions(-) diff --git a/ml/eda.ipynb b/ml/eda.ipynb index a40715e..f492c52 100644 --- a/ml/eda.ipynb +++ b/ml/eda.ipynb @@ -10,22 +10,24 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 64, "id": "c1f8b06a", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", + "import numpy as np\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "from sqlalchemy import create_engine\n", "from datetime import datetime\n", + "import warnings\n", "\n", - "# Configuración visual\n", + "warnings.filterwarnings(\"ignore\")\n", "sns.set(style=\"whitegrid\")\n", "plt.rcParams[\"figure.figsize\"] = (12, 6)\n", "\n", - "# Conexión a la base de datos local\n", + "# Conexión a la base de datos\n", "DATABASE_URL = \"postgresql://devsaieh:saiehpass@localhost:5433/devtest_db\"\n", "engine = create_engine(DATABASE_URL)\n" ] @@ -40,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 65, "id": "4cfbff17", "metadata": {}, "outputs": [ @@ -79,15 +81,15 @@ " 1\n", " 4\n", " 3\n", - " 2025-06-24 10:03:00\n", + " 2025-06-25 10:03:00\n", " \n", " \n", " 1\n", " 2\n", " 1\n", - " 11\n", " 12\n", - " 2025-06-24 10:07:00\n", + " 2\n", + " 2025-06-25 10:12:00\n", " \n", " \n", " 2\n", @@ -95,7 +97,7 @@ " 1\n", " 1\n", " 2\n", - " 2025-06-24 11:08:00\n", + " 2025-06-25 11:05:00\n", " \n", " \n", " 3\n", @@ -103,7 +105,7 @@ " 1\n", " 4\n", " 9\n", - " 2025-06-24 11:11:00\n", + " 2025-06-25 11:07:00\n", " \n", " \n", " 4\n", @@ -111,7 +113,7 @@ " 1\n", " 12\n", " 11\n", - " 2025-06-24 12:11:00\n", + " 2025-06-25 12:03:00\n", " \n", " \n", "\n", @@ -119,11 +121,11 @@ ], "text/plain": [ " id elevator_id floor destination_floor timestamp_called\n", - "0 1 1 4 3 2025-06-24 10:03:00\n", - "1 2 1 11 12 2025-06-24 10:07:00\n", - "2 3 1 1 2 2025-06-24 11:08:00\n", - "3 4 1 4 9 2025-06-24 11:11:00\n", - "4 5 1 12 11 2025-06-24 12:11:00" + "0 1 1 4 3 2025-06-25 10:03:00\n", + "1 2 1 12 2 2025-06-25 10:12:00\n", + "2 3 1 1 2 2025-06-25 11:05:00\n", + "3 4 1 4 9 2025-06-25 11:07:00\n", + "4 5 1 12 11 2025-06-25 12:03:00" ] }, "metadata": {}, @@ -163,40 +165,40 @@ " 1\n", " 1\n", " 3\n", - " 2025-06-24 10:00:00\n", - " 2025-06-24 10:02:00\n", + " 2025-06-25 10:00:00\n", + " 2025-06-25 10:02:00\n", " \n", " \n", " 1\n", " 2\n", " 1\n", - " 3\n", - " 2025-06-24 11:00:00\n", - " 2025-06-24 11:06:00\n", + " 10\n", + " 2025-06-25 11:00:00\n", + " 2025-06-25 11:02:00\n", " \n", " \n", " 2\n", " 3\n", " 1\n", - " 2\n", - " 2025-06-24 12:00:00\n", - " 2025-06-24 12:06:00\n", + " 11\n", + " 2025-06-25 12:00:00\n", + " 2025-06-25 12:02:00\n", " \n", " \n", " 3\n", " 4\n", " 1\n", - " 8\n", - " 2025-06-24 13:00:00\n", - " 2025-06-24 13:03:00\n", + " 10\n", + " 2025-06-25 13:00:00\n", + " 2025-06-25 13:05:00\n", " \n", " \n", " 4\n", " 5\n", " 1\n", - " 7\n", - " 2025-06-24 14:00:00\n", - " 2025-06-24 14:04:00\n", + " 6\n", + " 2025-06-25 14:00:00\n", + " 2025-06-25 14:08:00\n", " \n", " \n", "\n", @@ -204,11 +206,11 @@ ], "text/plain": [ " id elevator_id floor resting_start resting_end\n", - "0 1 1 3 2025-06-24 10:00:00 2025-06-24 10:02:00\n", - "1 2 1 3 2025-06-24 11:00:00 2025-06-24 11:06:00\n", - "2 3 1 2 2025-06-24 12:00:00 2025-06-24 12:06:00\n", - "3 4 1 8 2025-06-24 13:00:00 2025-06-24 13:03:00\n", - "4 5 1 7 2025-06-24 14:00:00 2025-06-24 14:04:00" + "0 1 1 3 2025-06-25 10:00:00 2025-06-25 10:02:00\n", + "1 2 1 10 2025-06-25 11:00:00 2025-06-25 11:02:00\n", + "2 3 1 11 2025-06-25 12:00:00 2025-06-25 12:02:00\n", + "3 4 1 10 2025-06-25 13:00:00 2025-06-25 13:05:00\n", + "4 5 1 6 2025-06-25 14:00:00 2025-06-25 14:08:00" ] }, "metadata": {}, @@ -224,9 +226,8 @@ "resting_df[\"resting_start\"] = pd.to_datetime(resting_df[\"resting_start\"])\n", "resting_df[\"resting_end\"] = pd.to_datetime(resting_df[\"resting_end\"])\n", "\n", - "# Vista inicial\n", "display(demand_df.head())\n", - "display(resting_df.head())" + "display(resting_df.head())\n" ] }, { @@ -239,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 66, "id": "76f3c9ae", "metadata": {}, "outputs": [ @@ -260,22 +261,47 @@ "floor 0\n", "resting_start 0\n", "resting_end 0\n", - "dtype: int64\n" + "dtype: int64\n", + "\n", + "RangeIndex: 458 entries, 0 to 457\n", + "Data columns (total 5 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 id 458 non-null int64 \n", + " 1 elevator_id 458 non-null int64 \n", + " 2 floor 458 non-null int64 \n", + " 3 destination_floor 458 non-null int64 \n", + " 4 timestamp_called 458 non-null datetime64[ns]\n", + "dtypes: datetime64[ns](1), int64(4)\n", + "memory usage: 18.0 KB\n" ] + }, + { + "data": { + "text/plain": [ + "None" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Revisar nulos\n", "print(\"Demand nulls:\\n\", demand_df.isnull().sum())\n", "print(\"Resting nulls:\\n\", resting_df.isnull().sum())\n", "\n", - "# Quitar nulos evidentes (por ahora ignoramos resting_end nulos porque pueden ser resting abiertos)\n", - "resting_df = resting_df.dropna(subset=[\"resting_start\"])\n", - "demand_df = demand_df.dropna(subset=[\"timestamp_called\"])\n", + "# Elimina duplicados\n", + "demand_df = demand_df.drop_duplicates().reset_index(drop=True)\n", + "resting_df = resting_df.drop_duplicates().reset_index(drop=True)\n", + "\n", + "# Elimina demandas fuera de rango de piso (seguridad extra)\n", + "MIN_FLOOR, MAX_FLOOR = 1, 12\n", + "demand_df = demand_df[(demand_df[\"floor\"] >= MIN_FLOOR) & (demand_df[\"floor\"] <= MAX_FLOOR)]\n", "\n", - "# Reset index por si es necesario\n", - "demand_df = demand_df.reset_index(drop=True)\n", - "resting_df = resting_df.reset_index(drop=True)\n" + "demand_df = demand_df[(demand_df[\"destination_floor\"] >= MIN_FLOOR) & (demand_df[\"destination_floor\"] <= MAX_FLOOR)]\n", + "\n", + "display(demand_df.info())\n", + "\n" ] }, { @@ -288,24 +314,13 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 67, "id": "88ceac61", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_13054/1710264984.py:2: FutureWarning: \n", - "\n", - "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", - "\n", - " sns.countplot(x=\"hour\", data=demand_df, palette=\"crest\")\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -315,8 +330,7 @@ } ], "source": [ - "demand_df[\"hour\"] = demand_df[\"timestamp_called\"].dt.hour\n", - "sns.countplot(x=\"hour\", data=demand_df, palette=\"crest\")\n", + "sns.countplot(x=\"hour\", data=demand_df.assign(hour=lambda df: df[\"timestamp_called\"].dt.hour), palette=\"crest\")\n", "plt.title(\"Demandas por hora\")\n", "plt.xlabel(\"Hora del día\")\n", "plt.ylabel(\"Número de llamadas\")\n", @@ -333,13 +347,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 68, "id": "b6a151c8", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -349,13 +363,79 @@ } ], "source": [ - "sns.histplot(resting_df[\"floor\"], bins=range(1, 14), discrete=True, color=\"salmon\")\n", - "plt.title(\"Pisos donde el ascensor descansa\")\n", + "sns.histplot(demand_df[\"floor\"], bins=range(MIN_FLOOR, MAX_FLOOR+2), discrete=True, color=\"salmon\")\n", + "plt.title(\"Pisos de origen de llamadas\")\n", "plt.xlabel(\"Piso\")\n", "plt.ylabel(\"Frecuencia\")\n", "plt.show()\n" ] }, + { + "cell_type": "markdown", + "id": "662944e1", + "metadata": {}, + "source": [ + "# Pisos de Destino" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "79ed9514", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(demand_df[\"destination_floor\"], bins=range(MIN_FLOOR, MAX_FLOOR+2), discrete=True, color=\"teal\")\n", + "plt.title(\"Pisos de destino de las llamadas\")\n", + "plt.xlabel(\"Piso de destino\")\n", + "plt.ylabel(\"Frecuencia\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e677cd1a", + "metadata": {}, + "source": [ + "# Hora vs piso origen" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "74e89042", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "demand_df[\"hour\"] = demand_df[\"timestamp_called\"].dt.hour\n", + "pivot = demand_df.pivot_table(index=\"hour\", columns=\"floor\", values=\"id\", aggfunc='count', fill_value=0)\n", + "sns.heatmap(pivot, annot=True, fmt=\"d\", cmap=\"YlGnBu\")\n", + "plt.title(\"Llamadas por hora y piso\")\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "id": "08ae251e", @@ -366,7 +446,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 71, "id": "53694334", "metadata": {}, "outputs": [ @@ -381,7 +461,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -419,13 +499,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 72, "id": "f9ed7b4d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+4AAAIsCAYAAABss/O1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVJdJREFUeJzt3XlclPX+///nDIIMKJBldgxQhEBRXMpE1DSN8qCWldrm9inLNk09v87J6mhZln3aTglmiS2Wlabp6WRkZdpm2skWbbFcEEUrK03WYZG5fn/4ZT5OuDAjMO+Rx/1284ZzXe+5rhfv6z3MPOfabJZlWQIAAAAAAEay+7sAAAAAAABwdAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAJxULMvSCy+8oJycHH+XAgAAUCcI7gCAgDJgwABNnTr1qPOfffZZzZ8/X126dGmQejIzM5WUlHTSrKexysnJUY8ePVRSUuLvUrw2depUDRgwwN9l1IkpU6Zo0qRJ/i4DAIxDcAeARmLZsmVKSkpy/0tJSVGfPn00btw4vfjiiyouLvZ3iSfsiy++0Lx58zRv3jydeeaZ/i4HAaKqqkqZmZkaNWqUwsPD/V2OkZxOpzIzM/XZZ5/V63puuOEGvfvuu/rhhx/qdT0AEGia+LsAAEDDuu222xQdHa2DBw/q999/13//+189+OCDeuGFF/TUU0+pffv2/i7xmFauXCmbzXbEebm5uZozZ46Sk5MbuCoEsjVr1mjHjh268sor/V2KT+6//35ZllWv63A6ncrKytKECROUmppab+tJTk5Wp06d9Nxzz+nhhx+ut/UAQKAhuANAI9O3b1+lpKS4H994441at26dbrrpJt1yyy3KyclRaGjoCa/n4MGDcrlcCgkJOeFlHe5YyxsxYkSdrguNw+uvv66zzz5brVq18ncpPgkODvZ3CXUqIyNDmZmZKikp4QgIAPh/OFQeAKC0tDTdcsst2rNnj/7zn/+4p48ePVqjR4+u0f7P59Tu3r1bSUlJevbZZ/XCCy8oPT1dKSkp2r59uyoqKvTkk0/q8ssv1znnnKOuXbvqmmuu0fr162ss1+VyacGCBbr44ouVkpKinj17aty4cfrmm2/cbY50jnt+fr5uu+029ejRQ126dNEVV1yhDz74wKPNZ599pqSkJOXk5Gju3LnuLzDGjh2rnTt31qqfNmzYoGHDhiklJUXp6elatGjRUdu+8cYbuvzyy9W5c2f16NFDU6ZM0c8//+yX9eTl5WnixInq3bu3UlJS1LdvX02ZMkVFRUU1ljV8+HB16dJF5557rkaOHKlPPvnEPX/VqlUaP368+vTpo06dOik9PV1z5sxRVVWVx3JGjx6tIUOGaNu2bRo9erS6dOmi8847T9nZ2TXqf+mllzR48GD3Oi+//HK9+eabHm2+//57XX/99Tr77LPVrVs3jR07Vl9//bVHm8rKSmVlZemiiy5SSkqKUlNTdfXVV2vt2rXH7Ovy8nJ9/PHH6tWrl8/9683veyRJSUm677779Pbbb2vQoEHq3LmzrrzySv3444+SpEWLFunCCy9USkqKRo8erd27d3s8/1ivx8WLFys9PV2dOnXSsGHDtGnTphq1H+81vnv3bqWlpUmSsrKy3KfbZGZmutuvW7dO11xzjbp27aru3bvr5ptv1vbt2z2WWVxcrAceeEADBgxQp06dlJaWpmuvvVbfffedR7tevXqptLRUn376aa36DwAaA/a4AwAkSUOHDtXjjz+uTz75RFdccYVPy1i2bJnKy8t1xRVXKCQkRJGRkSouLtaSJUs0ZMgQjRgxQiUlJVq6dKmuv/56LVmyRB06dHA//+6779ayZcvUt29fDR8+XFVVVdqwYYM2btzocZTA4X7//XddddVVcjqdGj16tE455RQtX75cN998s2bPnq0LL7zQo312drZsNpuuu+46FRcXa/78+br99tu1ZMmSY/5uP/74o8aNG6cWLVpo4sSJOnjwoDIzM3XqqafWaDt37lw9+eSTysjI0PDhw7V//34tXLhQI0eO1L///W9FREQ02HoqKio0btw4VVRUaNSoUTrttNO0d+9effDBByosLFTz5s0lHQpkmZmZ6tatm2677TYFBwdr48aNWr9+vfr06SNJWr58ucLCwnTttdcqLCxM69ev1+zZs1VcXKw77rjDo7aCggJdf/31uvDCC5WRkaF33nlHjz76qBITE9WvXz9J0muvvaaZM2dq4MCBGjNmjMrLy/Xjjz9q48aNuvjiiyVJW7du1ciRIxUeHq7rr79eTZo00eLFizV69GgtXLjQfRHCrKwsPfPMMxoxYoQ6d+6s4uJiffvtt/ruu+/Uu3fvo/b3t99+q8rKyiOeXuHNdqzN73ssGzZs0OrVq3XNNddIkubNm6ebbrpJ119/vV555RVdc801Kigo0Pz583XXXXfpxRdfPO4yV6xYoZKSEl155ZWy2WyaP3++Jk6cqFWrVnm1l75Fixa69957de+99+rCCy90v6aqL5b46aef6oYbblB0dLQmTJigsrIyLVy4UFdffbWWLVum6OhoSdI999yjd955R6NGjVJ8fLwOHDigL774Qtu3b1fHjh3d60tISFBoaKi+/PLLGq9fAGi0LABAo/D6669biYmJ1qZNm47a5pxzzrEuvfRS9+NRo0ZZo0aNqtHujjvusPr37+9+nJ+fbyUmJlpnn322tW/fPo+2Bw8etMrLyz2mFRQUWL169bLuvPNO97R169ZZiYmJ1v33319jfS6Xy/3//v37W3fccYf78QMPPGAlJiZan3/+uXtacXGxNWDAAKt///5WVVWVZVmWtX79eisxMdHKyMjwqGfBggVWYmKi9eOPPx61XyzLsm655RYrJSXF2rNnj3vatm3brA4dOliJiYnuabt377Y6dOhgzZ071+P5P/74o5WcnFxjen2v5/vvv7cSExOtt99++6jrzMvLs9q3b2/deuut7v6qdnjfO53OGs+dNm2a1aVLF48+HTVqlJWYmGgtX77cPa28vNzq3bu3NXHiRPe0m2++2Ro8ePBR67KsQ/3RsWNHa9euXe5pe/futbp162aNHDnSPe2SSy6xxo8ff8xlHclrr712xO3vzXas7e97NImJiVanTp2s/Px897RFixZZiYmJVu/eva2ioiL39Mcee8xKTEz0aHu012OPHj2sAwcOuKevWrXKSkxMtFavXu1Re21e4/v27bMSExOt2bNn12g7dOhQKy0tzfrjjz/c0zZv3my1b9/e+sc//uGeds4551gzZsw4bn9YlmVddNFF1vXXX1+rtgDQGHCoPADALSws7IRuh3XRRRepRYsWHtOCgoLc56W7XC4dOHBABw8eVKdOnfT999+727377ruy2WyaMGFCjeUe7WJ0kvThhx+qc+fO6t69u3taeHi4rrzySu3Zs0fbtm3zaH/55Zd7nCdf/bz8/PyjrqOqqkqffPKJ0tPT1bp1a/f0+Ph4997oau+9955cLpcyMjK0f/9+97/TTjtNbdq0OeZVuetjPc2aNZMkffLJJ3I6nUdc76pVq+RyuXTrrbfKbvf8aHB43x9+7YPi4mLt379f3bt3l9PpVG5ursfzwsLCNHToUPfjkJAQpaSkePRzRESEfvnllxqHbx/eH2vXrlV6erpiYmLc008//XQNGTJEX3zxhftuCBEREdq6davy8vKOuKyjOXDggCQpMjLSY7q327E2v++xpKWlufdMS3IfSXDRRRe5t6Ekde7cWdKxx2u1QYMGefxetRnr3vr111+1efNmXXbZZYqKinJPb9++vXr16qUPP/zQPS0iIkIbN27U3r17j7vcyMhI/fHHH3VWJwAEOg6VBwC4lZaWHvGQ7No6PHgcbvny5Xruuee0Y8cOVVZWHrH9rl27dPrpp3t8+K+Nn3766Yj3bG/Xrp17fmJionv64YFYkvtw58LCwqOuY//+/SorK1ObNm1qzIuLi/MIJ3l5ebIsSxdddNERl9WkydHfeutjPTExMbr22mv1/PPP680331T37t01YMAAXXLJJe7D5Hft2iW73a74+Pij1iYdOmz9iSee0Pr162vcPvDP58ufccYZNb5wiYyMdJ+3LR269denn36qESNGqE2bNurdu7eGDBmic845x90fTqdTcXFxNWqJj4+Xy+XSzz//rLPOOku33XabbrnlFg0cOFCJiYnq06ePhg4dWuu7JFh/uiq7t9uxNr/vsfzlL3/xeFwd1s844wyP6dXb7Fjj9WjLrA7xtXlubf3000+SdNRt9Mknn6i0tFRhYWG6/fbbNXXqVJ1//vnq2LGj+vXrp0svvdTjS5lqlmUd8ws7AGhsCO4AAEnSL7/8oqKiIsXGxh637Z8vRlbtSFejf+ONNzR16lSlp6dr3LhxOvXUUxUUFKRnnnmmTvf81daf9yhX+3Nw85XL5ZLNZlN2draCgoJqzA8LC2vw9UydOlWXXXaZ3n//fa1du1YzZ87UM888o9dee61GMDyawsJCjRo1Ss2aNdNtt92m2NhYNW3aVN99950effRRuVwuj/ZHqunP4uPjtXLlSn3wwQf6+OOP9e677+qVV17Rrbfeqttuu61WdVU799xz9d5777l/x6VLl2rBggWaMWPGMe82UP1FUUFBgUdfeLsda/P7HsvRnn+06bUZryfy3KO9xk/EoEGD1L17d7333ntau3atnn32WWVnZyszM7PGdQAKCwuP+AUWADRWBHcAgKRDAVuSxyHZkZGRRwzX1XvZauOdd95RTEyMsrKyPPagzZ4926NdbGysPvnkEx04cMCrve6tW7fWjh07akyvPnT7z3vYfdGiRQuFhoYe8erzf153bGysLMtSdHT0EfdC+ms91VcCv+WWW/Tll1/q6quv1quvvqopU6YoNjZWLpdL27dv97hY4OH++9//6sCBA8rKytK5557rnv7nK5x7KywsTIMGDdKgQYNUUVGhiRMn6umnn9aNN96oFi1ayOFwHHX72u12j73KUVFRGjZsmIYNG6aSkhKNGjVKmZmZxwzu1UdmVF+JvdqJbMdAUtvX+NH2fle/vo62jU455RSPLzlOP/10jRw5UiNHjtS+fft02WWX6emnn/YI7gcPHtTPP//scaV8AGjsOMcdAKB169bpqaeeUnR0tC655BL39JiYGOXm5mr//v3uaT/88IO+/PLLWi+7eq/f4Xv5Nm7cWON2XhdddJEsy1JWVlaNZRxrD2G/fv20adMmffXVV+5ppaWleu2113TmmWcqISGh1rUeTVBQkPr06aNVq1Z5BJrt27d73C6t+vcICgpSVlZWjbotyzrmebv1sZ7i4mIdPHjQY35iYqLsdrsqKiokSenp6bLb7ZozZ06NPefVy64+UuHwdVVUVOiVV1456u9zPH/ui5CQEMXHx8uyLFVWViooKEi9e/fW+++/7/EFwe+//64VK1bonHPOcR9S/udlhYeHKzY21v07Hk2nTp0UHBysb7/91mP6iWzHQFLb17jD4ZBU8zD7008/XR06dNC///1vj3lbtmzR2rVr3YG8qqqqxukUp556qk4//fQa22jbtm0qLy9Xt27dTvwXBICTBHvcAaCR+eijj5Sbm6uqqir9/vvv+uyzz7R27Vq1bt1ac+fOVdOmTd1thw8frhdeeEHjxo3T8OHDtW/fPi1atEgJCQm1vojd+eefr3fffVe33nqrzj//fO3evdu9jNLSUne7nj17aujQoXrppZe0c+dOnXfeeXK5XPriiy+UmpqqUaNGHXH548eP11tvvaUbbrhBo0ePVmRkpP79739r9+7dyszMPOqh8d6aOHGiPv74Y40cOVJXX321qqqqtHDhQiUkJHicxxwbG6vJkyfrscce0549e5Senq7w8HDt3r1bq1at0hVXXKFx48Y12HrWr1+v++67T3/961/Vtm1bVVVV6Y033lBQUJAGDhwoSWrTpo1uuukmPfXUU7rmmmt00UUXKSQkRN98841OP/10/X//3/+nbt26KTIyUlOnTtXo0aNls9n0xhtvnNApBuPGjdNpp52ms88+W6eeeqpyc3O1cOFC9evXzx3IJ0+erE8//VTXXHONrrnmGgUFBWnx4sWqqKjQ3//+d/eyBg8erB49eqhjx46KiorSN99847712LE0bdpUffr00bp16zRp0iSv+zfQ1fY1HhoaqoSEBL399ttq27atoqKidNZZZykxMVH/+Mc/dMMNN+jKK6/U8OHD3beDa968uftikyUlJerXr58GDhyo9u3bKywsTJ9++qm++eYbTZ061aOmTz/9VA6HQ7169WrQvgAAkxHcAaCRqT5EPTg4WFFRUUpMTNRdd92lyy+/3OPq1dKhc5D/93//V7Nnz9asWbOUkJCghx9+WCtWrNB///vfWq3v8ssv1++//67Fixfrk08+UUJCgh555BGtXLmyxjJmzZqlpKQkLV26VA8//LCaN2+uTp06HXPP22mnnaZFixbpkUce0cKFC1VeXq6kpCQ9/fTTOv/8873rnGNo3769nn32Wc2aNUuzZ8/WGWecoYkTJ+q3336rcQGy8ePHq23btnrhhRc0Z84cSYcuMta7d+/jHv5b1+tJSkpSnz59tGbNGu3du1cOh0NJSUnKzs5W165d3cuaNGmSoqOjtXDhQv3rX/9yt6u+Uvopp5yip59+Wv/7v/+rJ554QhEREbrkkkuUlpbmc4C98sor9eabb+r5559XaWmpzjjjDI0ePVq33HKLu81ZZ52ll19+WY899pieeeYZWZalzp0765FHHvG4KOHo0aO1evVqrV27VhUVFWrdurUmT55cq9qGDRumiRMn6ueff/Y49P5EtmOg8OY1PnPmTN1///2aNWuWKisrNWHCBCUmJqpXr16aP3++Zs+erdmzZ6tJkyY699xz9fe//9194bnQ0FBdffXVWrt2rd59911ZlqXY2Fjdc8897nvXV1u5cqUuvPDCGn+PAKAxs1l1dTUeAACAAFRVVaVBgwYpIyNDkydP9nc5jVr1reWWL19+1OstAEBjxDnuAACgUQsKCtKkSZP0yiuv1PoUENSPefPmaeDAgYR2APgT9rgDAAAAAGAw9rgDAAAAAGAwgjsAAAAAAAYjuAMAAAAAYDCCOwAAAAAABuM+7pK++uorWZal4OBgf5cCAAAAAGgEKisrZbPZ1K1bt+O2ZY+7JMuyFAgX17csSxUVFQFRK8zAmIG3GDPwFmMG3mLMwFuMGXgrUMaMNznUyD3uy5cv14IFC7R9+3aFhYUpJSVFWVlZCg0NlSStXr1aTzzxhHbs2KHWrVtr/PjxGjZsmM/rq97TnpKSUif115fS0lJt3rxZCQkJCgsL83c5CACMGXiLMQNvMWbgLcYMvMWYgbcCZcx88803tW5rXHCfO3eusrOzddNNN6lr1676448/tG7dOlVVVUmSNmzYoAkTJmj48OG66667tH79et19990KDw/XX//6Vz9XDwAAAABA3TIquOfm5iorK0tPPfWU+vXr554+cOBA9//nzp2rzp0767777pMk9ezZU/n5+Zo9ezbBHQAAAABw0jHqHPdly5YpOjraI7QfrqKiQp999lmNgD5o0CBt375du3fvbogyAQAAAABoMEYF940bNyoxMVFPPfWU0tLS1KlTJ1111VXauHGjJGnXrl2qrKxUu3btPJ4XHx8v6dAeewAAAAAATiZGHSr/22+/6dtvv9WWLVt0zz33yOFw6Omnn9Z1112nd999VwUFBZKkiIgIj+dVP66e7wvLslRaWup78Q3A6XR6/ASOhzEDbzFm4C3GDLzFmIG3GDPwVqCMGcuyZLPZatXWqOBeHZ6ffPJJtW/fXpLUpUsXDRgwQAsXLlSfPn3qbd2VlZXavHlzvS2/LuXl5fm7BAQYxgy8xZiBtxgz8BZjBt5izMBbgTBmQkJCatXOqOAeERGhqKgod2iXpKioKCUnJ2vbtm0aPHiwJKmoqMjjeYWFhZKkyMhIn9cdHByshIQEn5/fEJxOp/Ly8tS2bVs5HA5/l4MAwJiBtxgz8BZjBt5izMBbjBl4K1DGzLZt22rd1qjgnpCQoF27dh1xXnl5uWJjYxUcHKzc3Fydd9557nnV57b/+dx3b9hsNqPv8Xc4h8MRMLXCDIwZeIsxA28xZuAtxgy8xZiBt0wfM7U9TF4y7OJ0/fv314EDBzwOWf/jjz/03XffqWPHjgoJCVFqaqreeecdj+fl5OQoPj5e0dHRDV0yAAAAAAD1yqg97unp6UpJSdFtt92mKVOmqGnTppo3b55CQkJ0zTXXSJJuvvlmjRkzRvfee68yMjL02WefacWKFfrXv/7l5+oBAAAAAKh7Ru1xt9vtmjdvnrp27arp06frb3/7m5o1a6aXX35ZLVu2lCR1795dmZmZ+uKLLzRu3DitWLFCM2fOVEZGhp+rBwAAAACg7hm1x12SWrRooUceeeSYbS644AJdcMEFDVQRAAAAAAD+Y9QedwAAAAAA4IngDgAAAACAwQjuAAAAAAAYjOAOAAAAAIDBCO4AAAAAABiM4A4AAAAAgMEI7gAAAAAAGIzgDgBws9lscjgcstls/i4FAAAA/08TfxcAADg2V5VL9qCG+Z7V4XAoOTnZp+c2ZJ0AAACNCcEdAAxnD7Lrowc+UsHOgnpfl8vlUpmzTKGOUNnttQ/hkW0i1ffuvvVYGQAAQONFcAeAAFCws0D7t+6v9/VUuapUWlKqsPAwBdmD6n19AAAAOD6OaQQAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AABwQoKDg2Wz2fxdBgAAJ60m/i4AAAAELpvNpo7JHRXUJMjfpRyXq8olexD7LAAAgYfgDgAATkhQkyB9cP8HKsov8ncpRxXZJlJ97+7r7zIAAPAJwR0AAJywgp0FOrD9gL/LAADgpMTxYgAAAAAAGIzgDgAAAACAwQjuAAAAAAAYjOAOAAAAAIDBCO4AAAAAABiM4A4AAAAAgMEI7gAAAAAAGIzgDgAAAACAwQjuAAAAAAAYjOAOAAAAAIDBCO4AAAAAABiM4A4AAAAAgMEI7gAAAAAAGIzgDgAAAACAwQjuAAAAAAAYjOAOAAAAAIDBCO4AAAAAABiM4A4AAAAAgMEI7gAAAAAAGIzgDgAAAACAwQjuAAAAAAAYzKjgvmzZMiUlJdX49+ijj3q0W7JkiQYOHKiUlBRdcsklWrNmjZ8qBgAAAACgfjXxdwFHMn/+fDVv3tz9uFWrVu7/v/XWW5o2bZpuuukm9ezZUzk5OZowYYJefvllde3a1Q/VAgAAAABQf4wM7h07dlSLFi2OOG/27NkaPHiwJk+eLEnq2bOntmzZojlz5ig7O7sBqwQAAAAAoP4Zdaj88eTn5ysvL08ZGRke0wcNGqR169apoqLCT5UBAAAAAFA/jAzuQ4YMUYcOHXTBBRfomWeeUVVVlSQpNzdXkhQXF+fRPj4+XpWVlcrPz2/wWgEAAAAAqE9GHSrfsmVLTZw4UV26dJHNZtPq1av1xBNPaO/evZo+fboKCgokSRERER7Pq35cPd8XlmWptLTU9+IbgNPp9PgJHA9jJvDZbDY5HA65XC5VuarqfX2uKpfHz1o/z3WovdPplGVZdV4XzFVRUdGgY9RXjFFz8N4EbzFm4K1AGTOWZclms9WqrVHB/bzzztN5553nftynTx81bdpUCxYs0E033VSv666srNTmzZvrdR11JS8vz98lIMAwZgKXw+FQcnKyypxlKi1puC8Xy8rKvGof7gyXJO3YscP4N0nULYfDoaioKFWUVzToGPUWY9Q8vDfBW4wZeCsQxkxISEit2hkV3I8kIyNDzz33nDZv3qzIyEhJUlFRkVq2bOluU1hYKEnu+b4IDg5WQkLCiRVbz5xOp/Ly8tS2bVs5HA5/l4MAwJgJfNXfwoY6QhUWHlbv63NVuVRWVqbQ0FDZg2p/NlWoI1TSoVOZ2JvZuFRfXyakaUiDjFFfMUbNwXsTvMWYgbcCZcxs27at1m2ND+6Ha9eunaRD57pX/7/6cXBwsGJiYnxets1mU1iYuR84DudwOAKmVpiBMRP47Ha7guxBDbe+IO/WZ7cfCvkmvzmiflR/udTQY9RbjFHz8N4EbzFm4C3Tx0xtD5OXDL043eFycnIUFBSk5ORkxcTEqG3btlq5cmWNNmlpabU+zAAAAAAAgEBh1B73cePGKTU1VUlJSZKk999/X6+99prGjBnjPjR+4sSJuv322xUbG6vU1FTl5ORo06ZNWrhwoT9LBwAAAACgXhgV3OPi4vT666/rl19+kcvlUtu2bXXXXXdp9OjR7jZDhgyR0+lUdna25s2bp7i4OGVlZalbt25+rBwAAAAAgPphVHD/5z//Wat2I0aM0IgRI+q5GgAAAAAA/M/4c9wBAAAAAGjMCO4AAAAAABiM4A4AAAAAgMEI7gAAAAAAGIzgDgAAAACAwQjuAAAAAAAYjOAOAAAAAIDBCO4BJjg4WDabzd9lAAAAAAAaSBN/F4Das9ls6pjcUUFNgvxdSq24qlyyB/HdEAAAAACcCIJ7gAlqEqQP7v9ARflF/i7lmCLbRKrv3X39XQYAAAAABDyCewAq2FmgA9sP+LsMAAAAAEAD4DhmAAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHADQ6riqXv0uolUCpEwAA1K8m/i4AAICGZg+y66MHPlLBzgJ/l3JUkW0i1ffuvv4uAwAAGIDgDgBolAp2Fmj/1v3+LgMAAOC4OFQeAAAAAACDEdwBAAAAADAYwR0AAAAAAIMR3IGTmM1mk8PhkM1m83cpAAAAAHzExemAAOGqcske5N13bQ6HQ8nJyfVU0ZH5UicAAACAoyO4AwHCl9tXuVwulTnLFOoIld1e/2Ga21cBAAAAdc/Y4F5SUqKMjAzt3btXS5cuVUpKinvekiVLNH/+fP3000+Ki4vTlClT1L9/fz9WCzQMb29fVeWqUmlJqcLCwxRkD6rHygAAAADUF2OPZ33qqadUVVVVY/pbb72ladOmKSMjQ9nZ2eratasmTJigr7/+uuGLBAAAAACgnhkZ3Ldv365XXnlFEydOrDFv9uzZGjx4sCZPnqyePXvqvvvuU0pKiubMmeOHSgEAAAAAqF9GBveZM2fqqquuUlxcnMf0/Px85eXlKSMjw2P6oEGDtG7dOlVUVDRkmQAAAAAA1DvjgvvKlSu1ZcsW3XrrrTXm5ebmSlKNQB8fH6/Kykrl5+c3SI0AAAAAADQUoy5O53Q69dBDD2nKlClq1qxZjfkFBYeuph0REeExvfpx9XxfWJal0tJSn5/fECoqKuRwOORyuVTlqnn+v0lcLpekQ9vUsiw/VxP4qu/H7u22d1W5PH7WN7Z73fN12/vK1zETSNu+ofvUV4HSp4Hy3hQo/dkYOJ1Oj5/A8TBm4K1AGTOWZclms9WqrVHBfe7cuTr11FM1bNiwBl93ZWWlNm/e3ODr9YbD4VBUVJQqyitUWmL2lwzhznBJ0o4dO4x/wQSC6vuxlznLfNr2ZWVl9VBVTWz3unei295X3o6ZQNr2/upTbwVKnwbKe1Og9GdjkpeX5+8SEGAYM/BWIIyZkJCQWrUzJrjv2bNHzz33nObMmaOioiJJcu8BLy0tVUlJiSIjIyVJRUVFatmypfu5hYWFkuSe74vg4GAlJCT4/PyGUH0Of0jTEIWFh/m5mmMLdYRKOnRaA3s2Tlz1N3GhjlCvtr2ryqWysjKFhobKHlT/Z8aw3euer9veV76OmUDa9g3dp74KlD4NlPemQOnPxsDpdCovL09t27aVw+HwdzkIAIwZeCtQxsy2bdtq3daY4L57925VVlZq/PjxNeaNGTNGXbp00WOPPSbp0Lnu7dq1c8/Pzc1VcHCwYmJifF6/zWZTWJi5Hzik//uwabfbjb8nt91+6AO/yS+UQOTrtrcHNcyYYbvXn4Z+3Xs7ZgJx25v+tzRQ+jRQ3psCpT8bE4fDYfxnL5iFMQNvmT5manuYvGRQcO/QoYNefPFFj2mbN2/WrFmzNGPGDKWkpCgmJkZt27bVypUrlZ6e7m6Xk5OjtLS0Wh9mAAAAAABAoDAmuEdERCg1NfWI8zp27KiOHTtKkiZOnKjbb79dsbGxSk1NVU5OjjZt2qSFCxc2ZLkAAAAAADQIY4J7bQ0ZMkROp1PZ2dmaN2+e4uLilJWVpW7duvm7NAAAAAAA6pzRwT01NVU//vhjjekjRozQiBEj/FARAAAAAAANq/4vMw0AAAAAAHxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwCNlqvK5e8SAAAAgONq4u8CAMBf7EF2ffTARyrYWeDvUo7qzNQzdfa4s/1dBgAAAPyI4A6gUSvYWaD9W/f7u4yjioyN9HcJAAAA8DMOlQcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHfUC0cLR8DcIztQ6gQAAADQOHE7ONSLkGYhAXGP7Mg2kep7d19/lwEAAAAAR0VwR70y/R7ZAAAAAGA6DpUHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgTWrbcMCAAbLZbF4t3GazadWqVV4XBQAAAAAADql1cO/Ro0eN4P7tt99q69atSkhIUFxcnCRpx44d2rZtm8466yx16tSpbqsFAAAAAKCRqXVwf+ihhzwer1q1SqtWrdLzzz+vtLQ0j3lr167V5MmTNWnSpLqpEgAAAACARsrnc9yffPJJjRo1qkZol6TevXtr5MiRevLJJ0+oOAAAAAAAGjufg/vOnTsVFRV11PlRUVHatWuXr4sHAAAAAAA6geAeGxurZcuWqaSkpMa84uJivf7664qJiTmh4gAAAAAAaOxqfY77n02ePFm33XabMjIydNlll6lNmzaSDu2JX758ufbt28eh8gAAAAAAnCCfg3t6errmzZunRx99VM8884zHvA4dOuiBBx7Qeeedd8IFAgAAAADQmPkc3CWpT58+6tOnj3777Tf99NNPkqTWrVurZcuWdVIcAAAAAACN3QkF92otW7YkrAMAAAAAUA9OOLj/8ssv+v7771VUVCTLsmrMv/TSS090FQAAAAAANFo+B/fy8nLdcccdevfdd+VyuWSz2dzB3WazudsR3AEAAAAA8J3Pt4N7/PHH9d5772ny5Ml66aWXZFmWHnroIT333HPq27ev2rdvrzfeeKMuawUAAAAAoNHxObi/8847uvzyyzV+/HglJCRIklq1aqVevXrpmWeeUfPmzfXyyy/XWaEAAAAAADRGPgf3ffv2qXPnzpKk0NBQSZLT6XTPHzhwoN57770TLA8AAAAAgMbN5+B+2mmn6Y8//pAkORwORUZGaseOHe75xcXFKi8vP/EKAQAAAABoxHy+OF3nzp315Zdfuh/3799fzz77rFq2bCmXy6UXXnhBXbt2rYsaAQAAAABotHwO7qNHj9bKlStVUVGhkJAQTZo0SV999ZX+8Y9/SJJiY2N1991311mhAAAAAAA0Rj4H9+7du6t79+7ux3/5y1/09ttva8uWLbLb7WrXrp2aNDnh28QDAAAAANCo1Wmyttvtat++fV0uEgAAAACARq3Wwf3zzz/3aQXnnnuuT88DAAAAAABeBPfRo0fLZrO5H1uW5fH4aDZv3uxbZQAAAAAAoPbB/cUXX/R4XFFRoUceeURlZWW64oorFBcXJ0nKzc3VkiVL5HA49Pe//71uqwUAAAAAoJGpdXDv0aOHx+NZs2YpODhYr732mpo2beqePmDAAI0cOVKjRo3Sxx9/rN69e9ddtQAAAAAANDJ2X5/45ptvaujQoR6hvZrD4dDQoUP1n//854SKAwAAAACgsfM5uDudTv32229Hnf/bb7/J6XT6ungAAAAAAKATCO5paWl68cUX9e6779aY98477+jFF19Ur169Tqg4AAAAAAAaO5/v437PPfdozJgxmjRpklq2bKk2bdpIknbt2qVff/1VsbGxmjZtWp0VCgAAAABAY+RzcG/VqpX+85//aNGiRfroo4/0008/SZISEhI0btw4XXHFFQoNDa2zQgEAAAAAaIx8Du6S1LRpU40dO1Zjx46tq3oAAAAAAMBhfD7HHQAAAAAA1L9a73EfPXq07Ha7nn32WTVp0kRjxow57nNsNpsWLFhQ62I+/PBDZWdna9u2bSouLlarVq2Unp6uCRMmqHnz5u52q1ev1hNPPKEdO3aodevWGj9+vIYNG1br9QAAAAAAECi8OlTe5XK5/29Z1nHb16bN4Q4cOKDOnTtr9OjRioqK0tatW5WZmamtW7fqueeekyRt2LBBEyZM0PDhw3XXXXdp/fr1uvvuuxUeHq6//vWvXq0PAAAAAADT1Tq4v/TSS8d8XBeGDh3q8Tg1NVUhISGaNm2a9u7dq1atWmnu3Lnq3Lmz7rvvPklSz549lZ+fr9mzZxPcAQAAAAAnHZ/Pcf/888+1f//+o87fv3+/Pv/8c18X7xYVFSVJqqysVEVFhT777LMaAX3QoEHavn27du/efcLrAwAAAADAJD4H9zFjxmjt2rVHnb9+/fpanQd/JFVVVSovL9d3332nOXPmaMCAAYqOjtauXbtUWVmpdu3aebSPj4+XJOXm5vq0PgAAAAAATOXz7eCOd/56RUWFgoKCfFp2//79tXfvXknSeeedp8cee0ySVFBQIEmKiIjwaF/9uHq+LyzLUmlpqc/PbwgVFRVyOBxyuVyqclX5u5xjqr4egum1VtfpdDq9viZDQ7LZbD5te1eVy+NnfQuU/pR879OG1tCvJV/HDNu+7gVKnwbKe1Og9Gdj4HQ6PX4Cx8OYgbcCZcxYliWbzVartl4F959++kl79uxxP87NzT3i4fCFhYVatGiRWrdu7c3i3ebNmyen06lt27Zp7ty5uummm/T888/7tKzaqqys1ObNm+t1HSfK4XAoKipKFeUVKi0x/EuG8gpJUnl5udG1hjvDJUk7duww+oXtcDiUnJysMmeZT/1ZVlZWD1XVFCj9KZ14nzYUf72WvB0zbPu6Fyh9GijvTYHSn41JXl6ev0tAgGHMwFuBMGZCQkJq1c6r4L5s2TJlZWXJZrPJZrPp6aef1tNPP12jnWVZCgoK0owZM7xZvFv79u0lSd26dVNKSoqGDh2q9957TwkJCZKkoqIij/aFhYWSpMjISJ/WJ0nBwcHu5ZuqouLQB/iQpiEKCw/zczXHFtL00ABs2rSp0bWGOkIlSXFxcUbvgan+Ji7UEepVf7qqXCorK1NoaKjsQT6fGVNrgdKfku992tAa+rXk65hh29e9QOnTQHlvCpT+bAycTqfy8vLUtm1bORwOf5eDAMCYgbcCZcxs27at1m29Cu4ZGRk666yzZFmWJk+erNGjR6t79+4ebaoPQezQoYNOO+00bxZ/RElJSQoODtauXbs0YMAABQcHKzc3V+edd567TfW57X8+990bNptNYWHmfuCQ/u/Dpt1uV5Ddt9MQGordbnf/NLnW6jpNfkEfztf+tAc1zHYItP6UAmeMNnSd3o4Ztn3dC5Q+DZT3pkDpz8bE4XAY/9kLZmHMwFumj5naHiYveRnc4+Pj3ReCmzVrlrp3766YmBjvqvPSxo0bVVlZqejoaIWEhCg1NVXvvPOOxo4d626Tk5Oj+Ph4RUdH12stAAAAAAA0NJ8vTnfZZZfVZR2SpAkTJqhTp05KSkpSaGiofvjhBz377LNKSkpSenq6JOnmm2/WmDFjdO+99yojI0OfffaZVqxYoX/96191Xg8AAAAAAP7mc3CXpO3bt+v111/X7t27VVBQUOOcMZvNpgULFtR6eZ07d1ZOTo7mzZsny7J05plnasSIERo3bpz7pP3u3bsrMzNTTzzxhJYuXarWrVtr5syZysjIOJFfBQAAAAAAI/kc3P/973/rrrvuUpMmTRQXF1fjFm3S8W8Z92fjx4/X+PHjj9vuggsu0AUXXODVsgEAAAAACEQ+B/esrCx16NBB2dnZatGiRV3WBAAAAAAA/h+f7w/166+/atiwYYR2AAAAAADqkc/BPSkpSb/++mtd1gIAAAAAAP7E5+A+depULV26VF9++WVd1gMAAAAAAA7j8znu2dnZat68uUaOHKmEhAT95S9/kd3u+T2AzWbT3LlzT7hIAAAAAAAaK5+D+5YtWyRJf/nLX1RSUqJt27bVaGOz2XyvDAAAAAAA+B7cV69eXZd1AAAAAACAI/D5HHcAAAAAAFD/fN7jfrji4mIVFxfL5XLVmNe6deu6WAUAAAAAAI3SCQX3V155RS+88ILy8/OP2mbz5s0nsgoAAAAAABo1nw+Vf/XVV3XfffcpNjZWkydPlmVZGjt2rMaPH6/TTjtN7du31wMPPFCXtQIAAAAA0Oj4HNwXLlyoPn36aP78+briiiskSf369dOUKVOUk5OjkpISHThwoK7qBAAAAACgUfI5uO/atUv9+/eXJAUHB0uSKisrJUnNmzfX8OHD9corr9RBiQAAAAAANF4+B/fmzZurqqpKktSsWTM5HA798ssv7vnh4eH6/fffT7xCAAAAAAAaMZ+D+1lnnaUffvjB/bhLly569dVXtXfvXv38889avHix2rZtWxc1AgAAAADQaPkc3C+55BJt3bpVFRUVkqSJEydq+/btOv/88zVgwADt2LFDkydPrqs6AQAAAABolHy+HdywYcM0bNgw9+NzzjlHb731llavXq2goCD17t1bcXFxdVIkAAAAAACNlVd73MvLyzV9+nS99NJLR5wfExOjsWPHyuVyacGCBe6L1QEAAAAAAN94FdwXL16s5cuX6/zzzz9mu/79++v111/XkiVLTqQ2AAAAAAAaPa+C+9tvv62LLrpIMTExx2wXExOjgQMH6q233jqh4gAAAAAAaOy8Cu5btmzROeecU6u2Z599tn788UefigIAAAAAAId4FdwrKysVHBxcq7bBwcHuK84DAAAAAADfeBXcTz/9dG3durVWbbdu3arTTz/dp6IAAAAAAMAhXgX3Xr166Y033tC+ffuO2W7fvn1644031KtXrxMqDgAAAACAxs6r4H7DDTeovLxcY8eO1caNG4/YZuPGjfqf//kflZeX6/rrr6+TIgEAAAAAaKyaeNM4JiZGTzzxhP72t7/pqquuUkxMjBITExUeHq6SkhJt3bpVu3btUmhoqB5//HHFxsbWV90AAAAAADQKXgV3STr//PP1n//8R9nZ2frggw+0atUq97zTTz9dI0aM0A033HDcW8YBAAAAAIDj8zq4S1J0dLRmzJghSSouLlZJSYnCw8PVrFmzOi0OAAAAAIDGzqfgfrhmzZoR2AEAAAAAqCdeXZwOAAAAAAA0LII7AAAAAAAGI7gDAAAAAGAwgjsAAAAAAAYjuAMAAAAAYDCCOwAAAAAABiO4AwAAAABgMII7AAAAAAAGI7gDAAAAAGAwgjsAAAAAAAYjuAMAAAAAYDCCOwAAAAAABiO4AwAAAABgMII7AAAAAAAGI7gDAAAAAGAwgjsAAAAAAAYjuAMAAAAAYDCCOwAAAAAABiO4AwAAAABgMII7AAAAAAAGI7gDAAAAAGAwgjsAAAAAAAYjuAMAAAAAYDCCOwAAAAAABiO4AwAAAABgMII7AAAAAAAGI7gDAAAAAGAwgjsAAAAAAAYjuAMAAAAAYDCCOwAAAAAABiO4AwAAAABgMII7AAAAAAAGI7gDAAAAAGAwgjsAAAAAAAYzKri//fbbuvnmm9W3b1917dpVQ4cO1dKlS2VZlke7JUuWaODAgUpJSdEll1yiNWvW+KliAAAAAADql1HB/YUXXpDD4dDUqVM1d+5c9e3bV9OmTdOcOXPcbd566y1NmzZNGRkZys7OVteuXTVhwgR9/fXX/iscAAAAAIB60sTfBRxu7ty5atGihftxWlqaDhw4oOeff1633HKL7Ha7Zs+ercGDB2vy5MmSpJ49e2rLli2aM2eOsrOz/VQ5AAAAAAD1w6g97oeH9modOnRQcXGxSktLlZ+fr7y8PGVkZHi0GTRokNatW6eKioqGKhUAAAAAgAZhVHA/ki+++EKtWrVSs2bNlJubK0mKi4vzaBMfH6/Kykrl5+f7o0QAAAAAAOqNUYfK/9mGDRuUk5OjO+64Q5JUUFAgSYqIiPBoV/24er4vLMtSaWmpz89vCBUVFXI4HHK5XKpyVfm7nGNyuVzunybXWl2n0+mscRFEk9hsNp+2vavK5fGzvgVKf0q+92lDa+jXkq9jhm1f9wKlTwPlvSlQ+rMxcDqdHj+B42HMwFuBMmYsy5LNZqtVW2OD+y+//KIpU6YoNTVVY8aMqff1VVZWavPmzfW+nhPhcDgUFRWlivIKlZYY/iVD+aHTFsrLy42uNdwZLknasWOH0S9sh8Oh5ORklTnLfOrPsrKyeqiqpkDpT+nE+7Sh+Ou15O2YYdvXvUDp00B5bwqU/mxM8vLy/F0CAgxjBt4KhDETEhJSq3ZGBvfCwkLdcMMNioqKUmZmpuz2Q0f0R0ZGSpKKiorUsmVLj/aHz/dFcHCwEhISTqDq+ld9Dn9I0xCFhYf5uZpjC2l6aAA2bdrU6FpDHaGSDp1+YfIemOpv4kIdoV71p6vKpbKyMoWGhsoeVP9nxgRKf0q+92lDa+jXkq9jhm1f9wKlTwPlvSlQ+rMxcDqdysvLU9u2beVwOPxdDgIAYwbeCpQxs23btlq3NS64l5WV6cYbb1RRUZEWL16s5s2bu+e1a9dOkpSbm+v+f/Xj4OBgxcTE+Lxem82msDBzP3BI//dh0263K8ge5Odqjq36yxbTa62u0+QX9OF87U97UMNsh0DrTylwxmhD1+ntmGHb171A6dNAeW8KlP5sTBwOh/GfvWAWxgy8ZfqYqe1h8pJhF6c7ePCgJk+erNzcXM2fP1+tWrXymB8TE6O2bdtq5cqVHtNzcnKUlpZW68MMAAAAAAAIFEbtcZ8xY4bWrFmjqVOnqri4WF9//bV7XnJyskJCQjRx4kTdfvvtio2NVWpqqnJycrRp0yYtXLjQf4UDAAAAAFBPjArua9eulSQ99NBDNea9//77io6O1pAhQ+R0OpWdna158+YpLi5OWVlZ6tatW0OXCwAAAABAvTMquK9evbpW7UaMGKERI0bUczUAAAAAAPifUee4AwAAAAAATwR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAABgLJvNJofDIZvN5u9SAL9p4u8CAAAAAAQWV5VL9qCG2QfocDiUnJzs03Mbsk6gPhHcAQAAAHjFHmTXRw98pIKdBfW+LpfLpTJnmUIdobLbax/CI9tEqu/dfeuxMqDhENwBAAAAeK1gZ4H2b91f7+upclWptKRUYeFhCrIH1fv6ABNx3AgAAAAAAAYjuAMAAAAAYDCCOwAAAAAABiO4AwAAAABgMII7AAAAAAAGI7gDAAAAAGAwo4L7zp07NX36dA0dOlTJyckaMmTIEdstWbJEAwcOVEpKii655BKtWbOmgSsFAAAAAKBhGBXct27dqg8//FBt2rRRfHz8Edu89dZbmjZtmjIyMpSdna2uXbtqwoQJ+vrrrxu2WAAAAAAAGkATfxdwuAEDBig9PV2SNHXqVH377bc12syePVuDBw/W5MmTJUk9e/bUli1bNGfOHGVnZzdkuQAAAAAA1Duj9rjb7ccuJz8/X3l5ecrIyPCYPmjQIK1bt04VFRX1WR4AAAAAAA3OqOB+PLm5uZKkuLg4j+nx8fGqrKxUfn6+P8oCAAAAAKDeGHWo/PEUFBRIkiIiIjymVz+unu8Ly7JUWlrqe3ENoKKiQg6HQy6XS1WuKn+Xc0wul8v90+Raq+t0Op2yLMvP1RydzWbzadu7qlweP+tboPSn5HufNrSGfi35OmbY9nUvUPo0UN6bAqU/GwOn0+nxE4Gnof+ONob3JtStQPk7Y1mWbDZbrdoGVHCvT5WVldq8ebO/yzgmh8OhqKgoVZRXqLTE8C8Zyg+dtlBeXm50reHOcEnSjh07jH5hOxwOJScnq8xZ5lN/lpWV1UNVNQVKf0on3qcNxV+vJW/HDNu+7gVKnwbKe1Og9GdjkpeX5+8S4CN//R09md+bUD8C4e9MSEhIrdoFVHCPjIyUJBUVFally5bu6YWFhR7zfREcHKyEhIQTK7CeVZ/DH9I0RGHhYX6u5thCmh4agE2bNjW61lBHqKRDp1+Y/E1s9TdxoY5Qr/rTVeVSWVmZQkNDZQ+q/zNjAqU/Jd/7tKE19GvJ1zHDtq97gdKngfLeFCj92Rg4nU7l5eWpbdu2cjgc/i4HPmjov6ON4b0JdStQ/s5s27at1m0DKri3a9dO0qFz3av/X/04ODhYMTExPi/bZrMpLMzcDxzS//2RtNvtCrIH+bmaY6u+0KDptVbXafIL+nC+9qc9qGG2Q6D1pxQ4Y7Sh6/R2zLDt616g9GmgvDcFSn82Jg6Hw/jPXjg23ptgOtP/ztT2MHkpwC5OFxMTo7Zt22rlypUe03NycpSWllbrwwwAAAAAAAgURu1xdzqd+vDDDyVJe/bsUXFxsTuk9+jRQy1atNDEiRN1++23KzY2VqmpqcrJydGmTZu0cOFCf5YOAAAAAEC9MCq479u3T5MmTfKYVv34xRdfVGpqqoYMGSKn06ns7GzNmzdPcXFxysrKUrdu3fxRMgAAAAAA9cqo4B4dHa0ff/zxuO1GjBihESNGNEBFAAAAAAD4V0Cd4w4AAAAAwLHYbDYFBwf7u4w6RXAHAAAnPUcLh1xVLn+XUWuBVCuAxiUQ/j45HA51TO7o1VXbTWfUofIAAAD1IaRZiOxBdn30wEcq2Fng73KOKbJNpPre3dffZQDAEQXC39LmMc11/rTzpUp/V1J3CO4AAKDRKNhZoP1b9/u7DAAIaKb/LXW5zD8qwFscKg8AAAAAgMEI7gAAAAAAGIzgDgAAAACAwQjuAAAAAAAYjOAOAACABmOz2eRwOE6q2zQBQH0juAMAAMAnvtzP2eFwKDk5WQ6Hox4qOrJAuO+0FDh1ou6x7XE83A4OAAAAPvHlfs4ul0tlzjKFOkJlt9f/PqTINpHqe3ffel9PXQiE+2NL0pmpZ+rscWf7u4yTCtsex0NwBwAAgM+8vZ9zlatKpSWlCgsPU5A9qB4rC0ym3x9bkiJjI/1dwkmJbY9j4VB5AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAwWkMF9+/btuvbaa9W1a1f17t1bDz/8sCoqKvxdFgAAAAAAda6JvwvwVkFBgcaOHau2bdsqMzNTe/fu1UMPPaSysjJNnz7d3+UBAAAAAFCnAi64L1q0SCUlJcrKylJUVJQkqaqqSjNmzNCNN96oVq1a+bdAAAAAAADqUMAdKv/RRx8pLS3NHdolKSMjQy6XS2vXrvVfYQAAAAAA1IOAC+65ublq166dx7SIiAi1bNlSubm5fqoKAAAAAID6YbMsy/J3Ed7o2LGjJk2apPHjx3tMHzJkiLp166b777/f62V++eWXsixLwcHBdVVmvbAsS3a7XWV/lMlV5fJ3OccU1DRITZs3VdmBMrkOmlurvYldoVGhCoSXgc1m874/rUPjxmazSbb6q61aIPWn5GOfNrAGfy35OGbY9nUvkPrUZrMZ/94UKO9LUgBue96b6kwg/G2SeG+qD2z7umUPsiv0lFC5XK5D48ZQlZWVstlsOvvss4/bNuDOca8P1RvT5I0q/V99oaeE+rmS2guNCoxaTd/21ejPuhcofRoodbLt616g9GmgvDcFynaXAmjbB0if0p91L1BqZdvXvUCp1W43+wBzm81W6/EZcME9IiJCRUVFNaYXFBQoMjLSp2V269btRMsCAAAAAKBemP0VxBG0a9euxrnsRUVF+u2332qc+w4AAAAAQKALuODet29fffrppyosLHRPW7lypex2u3r37u3HygAAAAAAqHsBd3G6goICDR48WHFxcbrxxhu1d+9ePfTQQ7r44os1ffp0f5cHAAAAAECdCrjgLknbt2/X/fffr6+++krh4eEaOnSopkyZopCQEH+XBgAAAABAnQrI4A4AAAAAQGMRcOe4AwAAAADQmBDcAQAAAAAwGMEdAAAAAACDEdwBAAAAADAYwR0AAAAAAIMR3AEAAAAAMBjBHQAAAAAAgxHcA8Dbb7+tm2++WX379lXXrl01dOhQLV26VJZl+bs0BICSkhL17dtXSUlJ+uabb/xdDgy2fPlyXXrppUpJSVFqaqquv/56lZWV+bssGOr999/XiBEj1K1bN/Xp00eTJk1Sfn6+v8uCIXbu3Knp06dr6NChSk5O1pAhQ47YbsmSJRo4cKBSUlJ0ySWXaM2aNQ1cKUxxvDFTXFyszMxMDR8+XN27d1evXr1000036ccff/RTxfC32v6dqbZq1SolJSUdt52pCO4B4IUXXpDD4dDUqVM1d+5c9e3bV9OmTdOcOXP8XRoCwFNPPaWqqip/lwHDzZ07V/fff78GDRqkZ599Vvfdd5+io6MZOziizz77TBMmTFBCQoLmzJmju+66Sz/88IOuu+46vuyBJGnr1q368MMP1aZNG8XHxx+xzVtvvaVp06YpIyND2dnZ6tq1qyZMmKCvv/66YYuFEY43Zn766SctXrxYvXv31hNPPKH7779fRUVFuvLKK7V9+3Y/VAx/q83fmWplZWV68MEHddpppzVQdXXPZrHb1nj79+9XixYtPKZNmzZNOTk5+vzzz2W38/0Ljmz79u0aPny47rjjDt1zzz1aunSpUlJS/F0WDJObm6uLL75YTz31lPr16+fvchAApk+frrVr12rVqlWy2WySpPXr12vs2LF6+eWX1b17dz9XCH9zuVzuzydTp07Vt99+qxUrVni0GThwoDp16qTHHnvMPe2qq65S8+bNlZ2d3aD1wv+ON2ZKS0tls9nkcDjc00pKSjRgwAANGTJE06ZNa/Ca4V+1+TtT7cknn9Tnn3+u6OjoY7YzGYkvAPw5tEtShw4dVFxcrNLSUj9UhEAxc+ZMXXXVVYqLi/N3KTDYsmXLFB0dTWhHrR08eFDh4eHu0C5JzZs3lyRO44IkHXenQn5+vvLy8pSRkeExfdCgQVq3bp0qKirqszwY6HhjJiwszCO0S1J4eLhiY2P166+/1mdpMFRtd17u2rVLzz//vP75z3/Wc0X1i+AeoL744gu1atVKzZo183cpMNTKlSu1ZcsW3Xrrrf4uBYbbuHGjEhMT9dRTTyktLU2dOnXSVVddpY0bN/q7NBjq8ssv1/bt2/Xyyy+rqKhI+fn5evzxx5WcnKyzzz7b3+UhAOTm5kpSjS+W4+PjVVlZyfUSUCuFhYXaunWr2rVr5+9SYLAHHnhAQ4cOVfv27f1dygkhuAegDRs2KCcnR9ddd52/S4GhnE6nHnroIU2ZMoUvd3Bcv/32mz755BO98cYbuueeezRnzhzZbDZdd9112rdvn7/Lg4G6d++urKwsPfbYY+revbvS09O1b98+ZWdnKygoyN/lIQAUFBRIkiIiIjymVz+ung8cyyOPPCKbzaarr77a36XAUKtXr9ZXX32lSZMm+buUE0ZwDzC//PKLpkyZotTUVI0ZM8bf5cBQc+fO1amnnqphw4b5uxQEAMuyVFpaqieffFJ//etf1a9fP82dO1eWZWnhwoX+Lg8G+vLLL/WPf/xDV1xxhRYsWKAnn3xSLpdL48eP5+J0ABrE66+/rtdee03Tp0/XGWec4e9yYKDy8nI9+OCDmjhx4hFPPQ40TfxdAGqvsLBQN9xwg6KiopSZmclF6XBEe/bs0XPPPac5c+aoqKhIktzXQigtLVVJSYnCw8P9WSIMExERoaioKI9DyKKiopScnKxt27b5sTKYaubMmerZs6emTp3qnta1a1edf/75euONN3TllVf6sToEgsjISElSUVGRWrZs6Z5eWFjoMR84kg8//FDTp0/XLbfcossuu8zf5cBQCxYskN1u1+DBg91/WyorK+VyuVRYWKjQ0FCFhIT4ucraI7gHiLKyMt14440qKirS4sWL3RcBAv5s9+7dqqys1Pjx42vMGzNmjLp06aLXXnvND5XBVAkJCdq1a9cR55WXlzdwNQgE27dv1wUXXOAx7YwzztApp5xy1LEEHK76nOTc3FyP85Nzc3MVHBysmJgYf5UGw3399deaNGmSLr300pPi8GfUn9zcXO3cuVNpaWk15p177rm69957A+o0C4J7ADh48KAmT56s3Nxcvfzyy2rVqpW/S4LBOnTooBdffNFj2ubNmzVr1izNmDGD28Ghhv79+2vZsmXavHmzOnToIEn6448/9N133+l//ud//FscjNS6dWt9//33HtP27NmjP/74Q2eeeaafqkIgiYmJUdu2bbVy5Uqlp6e7p+fk5CgtLS2g9oKh4Wzbtk033nijevbsqRkzZvi7HBjuhhtuqHFExrx587Rjxw7NmjVLbdu29U9hPiK4B4AZM2ZozZo1mjp1qoqLi/X111+75yUnJ/PmBg8RERFKTU094ryOHTuqY8eODVwRTJeenq6UlBTddtttmjJlipo2bap58+YpJCRE11xzjb/Lg4GuuuoqPfjgg5o5c6YGDBigAwcOuK+t8efbe6Fxcjqd+vDDDyUd+lKnuLhYK1eulCT16NFDLVq00MSJE3X77bcrNjZWqampysnJ0aZNm7i2RiN1vDFjWZbGjRunpk2bauzYsfr222/dz23WrJkSEhL8Ujf853hjJj4+XvHx8R7PWb58ufbu3XvUz8oms1nccNV4AwYM0J49e4447/3331d0dHQDV4RA89lnn2nMmDFaunQpe9xxRPv379esWbO0Zs0aVVZWqnv37rrzzjv5IIQjsixLixYt0quvvqr8/HyFh4era9eumjJlSo0PSWicdu/eXeN0imovvvii+0PzkiVLlJ2drZ9++klxcXH629/+pv79+zdkqTDE8caMpKNemLlHjx566aWX6q02mKm2f2cON3XqVH377bdasWJFfZdX5wjuAAAAAAAYjMuSAwAAAABgMII7AAAAAAAGI7gDAAAAAGAwgjsAAAAAAAYjuAMAAAAAYDCCOwAAAAAABiO4AwAAAABgMII7AACNWFJSkjIzM/1dBgAAOAaCOwAAJ4Fly5YpKSlJSUlJ2rBhQ435lmWpX79+SkpK0o033tigtX355ZfKzMxUYWFhg64XAICTBcEdAICTSNOmTbVixYoa0//73//ql19+UUhIiMf0TZs26eabb67Xmr766itlZWUR3AEA8BHBHQCAk0i/fv20cuVKHTx40GP6ihUr1LFjR7Vs2dJjetOmTdWkSZOGLBEAAHiJ4A4AwElk8ODBOnDggNauXeueVlFRoXfeeUcXX3xxjfZ/Psc9MzNTSUlJ2rlzp6ZOnaru3bvrnHPO0Z133imn0+lut3v3biUlJWnZsmXHXGZmZqYefvhhSdIFF1zgPpx/9+7dkqSDBw9qzpw5Sk9PV6dOnTRgwAA9/vjjqqio8FjmN998o3Hjxik1NVWdO3fWgAEDdOedd55ATwEAEDj4ih0AgJPImWeeqa5du+qtt95Sv379JEkfffSRioqKNGjQIL300ku1Ws7kyZMVHR2tv/3tb/r++++1ZMkStWjRQn//+9+9qufCCy9UXl6eVqxYoTvvvFOnnHKKJKlFixaSpH/+859avny5Bg4cqGuvvVabNm3SM888o+3bt2vOnDmSpH379mncuHE65ZRTNH78eEVERGj37t167733vKoFAIBARXAHAOAkc/HFF+uxxx5TWVmZQkND9eabb+rcc89Vq1atar2MDh066MEHH3Q/PnDggJYuXep1cG/fvr2Sk5O1YsUKpaenKzo62j3vhx9+0PLlyzVixAjNnDlTkjRy5Ei1aNFCzz33nNavX6+ePXvqq6++UkFBgZ599lmlpKS4nz9lyhSvagEAIFBxqDwAACeZjIwMlZeXa82aNSouLtYHH3xwxMPkj+Wqq67yeNy9e3cdOHBAxcXFdVbnhx9+KEm69tprPaZfd911HvObN28uSfrggw9UWVlZZ+sHACBQENwBADjJtGjRQmlpaVqxYoXee+89VVVVaeDAgV4to3Xr1h6PIyIiJEkFBQV1VueePXtkt9sVGxvrMb1ly5aKiIjQnj17JEk9evTQwIEDlZWVpZ49e+rmm2/W66+/XuM8eAAATlYEdwAATkJDhgzRRx99pEWLFqlv377u4F1bdvuRPyJYliVJstlsR5xfVVXlXaHHWNbh82fPnq3Fixdr1KhR2rt3r+666y5dfvnlKikp8Xp9AAAEGoI7AAAnoQsvvFB2u11ff/21hgwZUufLj4yMlKQa92b/6aefarQ9WjA/88wz5XK5tHPnTo/pv//+uwoLC3XmmWd6TO/ataumTJmiZcuW6dFHH9XWrVuVk5NzIr8GAAABgeAOAMBJKDw8XPfee68mTpyoAQMG1PnymzVrplNOOUUbNmzwmP7KK6/UaOtwOCRJRUVFHtOrr3q/YMECj+nPP/+8x/yCggL3nv5qHTp0kCQOlwcANApcVR4AgJPUZZddVq/LHzFihObNm6e7775bnTp10oYNG7Rjx44a7Tp27ChJ+te//qVBgwYpODhY/fv3V/v27XXZZZdp8eLFKiws1LnnnqtvvvlGy5cvV3p6unr27ClJWr58uV599VWlp6crNjZWJSUleu2119SsWTP17du3Xn9HAABMQHAHAAA+ufXWW7V//3698847evvtt9W3b1/Nnz9faWlpHu06d+6sSZMmadGiRfr444/lcrn0/vvvKywsTDNnzlR0dLSWL1+uVatW6bTTTtONN96oCRMmuJ/fo0cPffPNN8rJydHvv/+u5s2bq3Pnznr00UcVExPT0L82AAANzmb9+dgzAAAAAABgDM5xBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYAR3AAAAAAAMRnAHAAAAAMBgBHcAAAAAAAxGcAcAAAAAwGAEdwAAAAAADEZwBwAAAADAYP8/niwTJxVnRSoAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -447,22 +527,208 @@ "plt.show()\n" ] }, + { + "cell_type": "markdown", + "id": "dc45ea9c", + "metadata": {}, + "source": [ + "# Probabilidad de Demanda por hora y piso" + ] + }, { "cell_type": "code", - "execution_count": 32, - "id": "470ad7b9", + "execution_count": 73, + "id": "43eb1564", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
floor123456789101112
hour
100.1025640.1538460.0512820.0256410.0512820.0512820.1282050.0512820.0769230.0512820.1282050.128205
110.0833330.1388890.0555560.0833330.1666670.0833330.0555560.0555560.0833330.0833330.0555560.055556
120.1190480.0476190.1428570.0714290.0952380.0952380.0714290.0476190.0476190.0952380.0714290.095238
130.0882350.0882350.0588240.0882350.0882350.0882350.0882350.0588240.0000000.0294120.1176470.205882
140.0789470.2105260.1315790.0263160.0789470.0789470.0526320.1052630.0789470.0789470.0526320.026316
\n", + "
" + ], + "text/plain": [ + "floor 1 2 3 4 5 6 7 \\\n", + "hour \n", + "10 0.102564 0.153846 0.051282 0.025641 0.051282 0.051282 0.128205 \n", + "11 0.083333 0.138889 0.055556 0.083333 0.166667 0.083333 0.055556 \n", + "12 0.119048 0.047619 0.142857 0.071429 0.095238 0.095238 0.071429 \n", + "13 0.088235 0.088235 0.058824 0.088235 0.088235 0.088235 0.088235 \n", + "14 0.078947 0.210526 0.131579 0.026316 0.078947 0.078947 0.052632 \n", + "\n", + "floor 8 9 10 11 12 \n", + "hour \n", + "10 0.051282 0.076923 0.051282 0.128205 0.128205 \n", + "11 0.055556 0.083333 0.083333 0.055556 0.055556 \n", + "12 0.047619 0.047619 0.095238 0.071429 0.095238 \n", + "13 0.058824 0.000000 0.029412 0.117647 0.205882 \n", + "14 0.105263 0.078947 0.078947 0.052632 0.026316 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "import numpy as np\n", - "def expected_distance(prob_vector, resting_floor):\n", - " return np.sum([prob * abs(resting_floor - floor) for floor, prob in enumerate(prob_vector, start=MIN_FLOOR)])" + "calls_by_hour_floor = demand_df.groupby([\"hour\", \"floor\"]).size().unstack(fill_value=0)\n", + "prob_by_hour_floor = calls_by_hour_floor.div(calls_by_hour_floor.sum(axis=1), axis=0).fillna(0)\n", + "display(prob_by_hour_floor.head())\n", + "\n", + "prob_by_hour_floor.plot(kind=\"bar\", stacked=True, colormap=\"tab20\", width=1)\n", + "plt.title(\"Probabilidad de llamada por piso para cada hora\")\n", + "plt.ylabel(\"Probabilidad\")\n", + "plt.xlabel(\"Hora del día\")\n", + "plt.legend(title=\"Piso\", bbox_to_anchor=(1,1))\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "b5a91248", + "metadata": {}, + "source": [ + "# Calculo de Piso Optimo" ] }, { "cell_type": "code", - "execution_count": 33, - "id": "64595d23", + "execution_count": 74, + "id": "49865f07", "metadata": {}, "outputs": [ { @@ -495,74 +761,74 @@ " \n", " 0\n", " 10\n", - " 6\n", - " 2.222222\n", + " 7\n", + " 3.333333\n", " \n", " \n", " 1\n", " 11\n", - " 4\n", - " 3.090909\n", + " 5\n", + " 2.777778\n", " \n", " \n", " 2\n", " 12\n", - " 5\n", - " 3.444444\n", + " 6\n", + " 3.071429\n", " \n", " \n", " 3\n", " 13\n", - " 4\n", - " 2.769231\n", + " 6\n", + " 3.382353\n", " \n", " \n", " 4\n", " 14\n", - " 4\n", - " 2.555556\n", + " 5\n", + " 2.947368\n", " \n", " \n", " 5\n", " 15\n", - " 7\n", - " 2.300000\n", + " 6\n", + " 2.722222\n", " \n", " \n", " 6\n", " 16\n", - " 6\n", - " 2.400000\n", + " 4\n", + " 2.595238\n", " \n", " \n", " 7\n", " 17\n", - " 10\n", - " 3.000000\n", + " 7\n", + " 2.973684\n", " \n", " \n", " 8\n", " 18\n", - " 9\n", - " 3.100000\n", + " 8\n", + " 2.575000\n", " \n", " \n", " 9\n", " 19\n", - " 7\n", - " 2.700000\n", + " 9\n", + " 3.176471\n", " \n", " \n", " 10\n", " 20\n", - " 6\n", - " 3.000000\n", + " 7\n", + " 2.615385\n", " \n", " \n", " 11\n", " 21\n", - " 6\n", - " 2.700000\n", + " 5\n", + " 2.450000\n", " \n", " \n", "\n", @@ -570,26 +836,29 @@ ], "text/plain": [ " hour best_resting_floor expected_distance\n", - "0 10 6 2.222222\n", - "1 11 4 3.090909\n", - "2 12 5 3.444444\n", - "3 13 4 2.769231\n", - "4 14 4 2.555556\n", - "5 15 7 2.300000\n", - "6 16 6 2.400000\n", - "7 17 10 3.000000\n", - "8 18 9 3.100000\n", - "9 19 7 2.700000\n", - "10 20 6 3.000000\n", - "11 21 6 2.700000" + "0 10 7 3.333333\n", + "1 11 5 2.777778\n", + "2 12 6 3.071429\n", + "3 13 6 3.382353\n", + "4 14 5 2.947368\n", + "5 15 6 2.722222\n", + "6 16 4 2.595238\n", + "7 17 7 2.973684\n", + "8 18 8 2.575000\n", + "9 19 9 3.176471\n", + "10 20 7 2.615385\n", + "11 21 5 2.450000" ] }, - "execution_count": 33, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ + "def expected_distance(prob_vector, resting_floor):\n", + " # Devuelve la distancia esperada dada la probabilidad de cada piso\n", + " return np.sum([prob * abs(resting_floor - floor) for floor, prob in enumerate(prob_vector, start=MIN_FLOOR)])\n", + "\n", "best_resting_per_hour = []\n", "for hour in prob_by_hour_floor.index:\n", " probs = prob_by_hour_floor.loc[hour].values\n", @@ -603,7 +872,7 @@ " best_resting_per_hour.append({\"hour\": hour, \"best_resting_floor\": best_floor, \"expected_distance\": min_dist})\n", "\n", "resting_df_optimal = pd.DataFrame(best_resting_per_hour)\n", - "resting_df_optimal\n" + "display(resting_df_optimal)" ] }, { @@ -616,74 +885,307 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 75, "id": "47277bae", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hourweekdaydemand_countavg_floormost_common_flooravg_directionpeak_hours
010057.2000007-0.2000000.0
110175.00000020.1428570.0
210297.00000012-0.3333330.0
3103106.50000060.4000000.0
410478.5714298-0.1428570.0
\n", + "
" + ], + "text/plain": [ + " hour weekday demand_count avg_floor most_common_floor avg_direction \\\n", + "0 10 0 5 7.200000 7 -0.200000 \n", + "1 10 1 7 5.000000 2 0.142857 \n", + "2 10 2 9 7.000000 12 -0.333333 \n", + "3 10 3 10 6.500000 6 0.400000 \n", + "4 10 4 7 8.571429 8 -0.142857 \n", + "\n", + " peak_hours \n", + "0 0.0 \n", + "1 0.0 \n", + "2 0.0 \n", + "3 0.0 \n", + "4 0.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Demand: extraer features útiles\n", + "# Features de tiempo\n", "demand_df[\"weekday\"] = demand_df[\"timestamp_called\"].dt.weekday\n", + "demand_df[\"is_weekend\"] = demand_df[\"weekday\"] >= 5\n", "demand_df[\"hour\"] = demand_df[\"timestamp_called\"].dt.hour\n", "demand_df[\"day\"] = demand_df[\"timestamp_called\"].dt.date\n", "\n", - "# Etiqueta: ¿ocurre entre 8-10 AM o 17-19 PM?\n", + "# Etiqueta \"peak_hours\" (horas de alta demanda)\n", "demand_df[\"peak_hours\"] = demand_df[\"hour\"].apply(\n", " lambda h: 1 if (8 <= h < 10) or (17 <= h < 19) else 0\n", - ")\n" + ")\n", + "\n", + "# Si tienes destino\n", + "if \"destination_floor\" in demand_df.columns:\n", + " demand_df[\"direction\"] = np.sign(demand_df[\"destination_floor\"] - demand_df[\"floor\"])\n", + "else:\n", + " demand_df[\"direction\"] = np.nan\n", + "\n", + "# Features agregadas por hora/día (para ML)\n", + "features_by_hour = (\n", + " demand_df.groupby([\"hour\", \"weekday\"])\n", + " .agg(\n", + " demand_count=(\"id\", \"count\"),\n", + " avg_floor=(\"floor\", \"mean\"),\n", + " most_common_floor=(\"floor\", lambda x: x.mode().iloc[0]),\n", + " avg_direction=(\"direction\", \"mean\"),\n", + " peak_hours=(\"peak_hours\", \"mean\")\n", + " )\n", + " .reset_index()\n", + ")\n", + "display(features_by_hour.head())\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "5e98a1b5", + "metadata": {}, + "source": [ + "# Union con piso optimo" ] }, { "cell_type": "code", - "execution_count": 16, - "id": "5ff5141b", + "execution_count": 76, + "id": "e633a798", "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hourweekdaydemand_countavg_floormost_common_flooravg_directionpeak_hoursbest_resting_floor
010057.2000007-0.2000000.07
110175.00000020.1428570.07
210297.00000012-0.3333330.07
3103106.50000060.4000000.07
410478.5714298-0.1428570.07
\n", + "
" + ], "text/plain": [ - "Index(['id', 'elevator_id', 'floor', 'timestamp_called', 'hour', 'weekday',\n", - " 'day', 'peak_hours'],\n", - " dtype='object')" + " hour weekday demand_count avg_floor most_common_floor avg_direction \\\n", + "0 10 0 5 7.200000 7 -0.200000 \n", + "1 10 1 7 5.000000 2 0.142857 \n", + "2 10 2 9 7.000000 12 -0.333333 \n", + "3 10 3 10 6.500000 6 0.400000 \n", + "4 10 4 7 8.571429 8 -0.142857 \n", + "\n", + " peak_hours best_resting_floor \n", + "0 0.0 7 \n", + "1 0.0 7 \n", + "2 0.0 7 \n", + "3 0.0 7 \n", + "4 0.0 7 " ] }, - "execution_count": 16, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "demand_df.columns" + "dataset_ml = pd.merge(\n", + " features_by_hour,\n", + " resting_df_optimal[[\"hour\", \"best_resting_floor\"]],\n", + " on=\"hour\",\n", + " how=\"left\"\n", + ")\n", + "display(dataset_ml.head())" ] }, { "cell_type": "code", - "execution_count": 17, - "id": "1499e6df", + "execution_count": null, + "id": "37562577", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "Index(['id', 'elevator_id', 'floor', 'resting_start', 'resting_end',\n", - " 'duration_min'],\n", - " dtype='object')" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Dataset listo para entrenamiento ML: elevator_ml_dataset.csv\n" + ] } ], "source": [ - "resting_df.columns" + "dataset_ml.to_csv(\"dataset/elevator_ml_dataset.csv\", index=False)\n", + "print(\"✅ Dataset listo para entrenamiento ML: elevator_ml_dataset.csv\")" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "37562577", + "cell_type": "markdown", + "id": "4ebafb14", "metadata": {}, - "outputs": [], "source": [] } ], From e368064127bd1bc0d098dd432898b4e6ac799440 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 13:22:18 -0400 Subject: [PATCH 19/24] feat: add training jupyter --- ml/train.ipynb | 144 ++++++++++++++++++++++++++++++++++++++++++++ requirements-ml.txt | 10 +++ 2 files changed, 154 insertions(+) create mode 100644 ml/train.ipynb create mode 100644 requirements-ml.txt diff --git a/ml/train.ipynb b/ml/train.ipynb new file mode 100644 index 0000000..8d9a961 --- /dev/null +++ b/ml/train.ipynb @@ -0,0 +1,144 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "083261c1", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.model_selection import train_test_split, GridSearchCV\n", + "from sklearn.metrics import classification_report, ConfusionMatrixDisplay\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "hour_features_df = pd.read_csv(\"dataset/elevator_ml_dataset.csv\")\n", + "\n", + "features = ['hour', 'weekday', 'demand_count', 'avg_floor', 'most_common_floor',\n", + " 'avg_direction', 'peak_hours']\n", + "target = \"best_resting_floor\"\n", + "\n", + "X = hour_features_df[features]\n", + "y = hour_features_df[target]\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.2, random_state=42, stratify=y\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2673156", + "metadata": {}, + "outputs": [], + "source": [ + "param_grid = {\n", + " \"n_estimators\": [50, 100, 150],\n", + " \"max_depth\": [None, 4, 8],\n", + " \"min_samples_split\": [2, 4]\n", + "}\n", + "rf = RandomForestClassifier(random_state=42, n_jobs=-1, class_weight=\"balanced\")\n", + "grid = GridSearchCV(rf, param_grid, cv=3, scoring=\"accuracy\", verbose=1)\n", + "grid.fit(X_train, y_train)\n", + "print(\"Mejores parámetros:\", grid.best_params_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "best_rf = grid.best_estimator_\n", + "y_pred = best_rf.predict(X_test)\n", + "\n", + "print(classification_report(y_test, y_pred))\n", + "\n", + "# Matriz de confusión\n", + "cm = ConfusionMatrixDisplay.from_estimator(\n", + " best_rf, X_test, y_test, cmap=\"Blues\", display_labels=sorted(y.unique())\n", + ")\n", + "plt.title(\"Matriz de Confusión: Piso de Descanso Óptimo\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "importances = best_rf.feature_importances_\n", + "feature_names = X.columns\n", + "indices = np.argsort(importances)[::-1]\n", + "\n", + "plt.figure(figsize=(8,5))\n", + "plt.title(\"Importancia de Features\")\n", + "plt.bar(range(len(importances)), importances[indices], align=\"center\")\n", + "plt.xticks(range(len(importances)), [feature_names[i] for i in indices], rotation=45)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9410d8b", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "\n", + "joblib.dump(best_rf, \"/content/best_resting_floor_model.joblib\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86e16542", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3daf4068", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59ef98b0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c577c62", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements-ml.txt b/requirements-ml.txt new file mode 100644 index 0000000..a57359e --- /dev/null +++ b/requirements-ml.txt @@ -0,0 +1,10 @@ +ipykernel +notebook +jupyter +pandas +matplotlib +seaborn +sqlalchemy +psycopg2-binary +joblib +scikit-learn \ No newline at end of file From fc2d406f542d7692703cfbcb03858c9485bfc513 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 13:22:40 -0400 Subject: [PATCH 20/24] feat: added joblib --- requirements.txt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 1bf0f61..0150a28 100644 --- a/requirements.txt +++ b/requirements.txt @@ -9,4 +9,6 @@ pytest-cov requests python-dotenv psycopg2-binary -httpx \ No newline at end of file +httpx +numpy +joblb \ No newline at end of file From 437c45c1d9d61a5261a6e32f5a383d2a46434709 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 13:24:18 -0400 Subject: [PATCH 21/24] feat: schema for ml model --- app/schemas/model_input.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 app/schemas/model_input.py diff --git a/app/schemas/model_input.py b/app/schemas/model_input.py new file mode 100644 index 0000000..e69de29 From e32c1167de2a65340d32e561b9e2c22d08eed21c Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 13:26:55 -0400 Subject: [PATCH 22/24] add ml endpoint --- app/api/v1/endpoints/routes_model.py | 27 +++++++++++++++++++++++++++ app/main.py | 3 ++- 2 files changed, 29 insertions(+), 1 deletion(-) create mode 100644 app/api/v1/endpoints/routes_model.py diff --git a/app/api/v1/endpoints/routes_model.py b/app/api/v1/endpoints/routes_model.py new file mode 100644 index 0000000..47600f8 --- /dev/null +++ b/app/api/v1/endpoints/routes_model.py @@ -0,0 +1,27 @@ +from fastapi import APIRouter, HTTPException +from app.schemas.model_input import RestingFloorRequest +import joblib +import numpy as np +import os + +router = APIRouter() + +MODEL_PATH = os.path.join(os.path.dirname(__file__), "../../../ml/resting_floor_model.joblib") +model = joblib.load(MODEL_PATH) + +@router.post("/predict_resting_floor/") +def predict_resting_floor(request: RestingFloorRequest): + try: + features = [ + request.hour, + request.weekday, + request.demand_count, + request.avg_floor, + request.most_common_floor, + request.avg_direction, + request.peak_hours + ] + pred = model.predict([features])[0] + return {"best_resting_floor": int(pred)} + except Exception as e: + raise HTTPException(status_code=400, detail=str(e)) diff --git a/app/main.py b/app/main.py index f907073..318c10c 100644 --- a/app/main.py +++ b/app/main.py @@ -1,7 +1,8 @@ from fastapi import FastAPI -from app.api.v1.endpoints import routes_demand, routes_resting +from app.api.v1.endpoints import routes_demand, routes_resting, routes_model app = FastAPI() app.include_router(routes_demand.router) app.include_router(routes_resting.router) +app.include_router(routes_model.router) From 074282821ac37dfaa7da94318d656b17d3512967 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 19:14:26 -0400 Subject: [PATCH 23/24] feat: ml schema --- app/schemas/model_input.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/app/schemas/model_input.py b/app/schemas/model_input.py index e69de29..acbdea6 100644 --- a/app/schemas/model_input.py +++ b/app/schemas/model_input.py @@ -0,0 +1,10 @@ +from pydantic import BaseModel + +class RestingFloorRequest(BaseModel): + hour: int + weekday: int + demand_count: int + avg_floor: float + most_common_floor: int + avg_direction: float + peak_hours: int From 3c246c4274f492bc54488c614f824c3d8ec43c25 Mon Sep 17 00:00:00 2001 From: martinsaieh Date: Wed, 25 Jun 2025 19:24:02 -0400 Subject: [PATCH 24/24] feat: change model route --- ml/train.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ml/train.ipynb b/ml/train.ipynb index 8d9a961..e312a1c 100644 --- a/ml/train.ipynb +++ b/ml/train.ipynb @@ -91,7 +91,7 @@ "source": [ "import joblib\n", "\n", - "joblib.dump(best_rf, \"/content/best_resting_floor_model.joblib\")" + "joblib.dump(best_rf, \"/ml/models/best_resting_floor_model.joblib\")" ] }, {