sklip 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

sklip/__init__.py

@@ -1,5 +1,5 @@
 from .core import s,ClusterKMeans,figsize,x
-__version__ = "0.5.0"
+__version__ = "0.6.0"
 __all__ = ['s','ClusterKMeans', 'figsize','x']
 
 s(1)

sklip/core.py

@@ -1,123 +1,386 @@
 import pyperclip
 
 SNIPPETS = {
-    1: "import 4333432numpy as np \nimport pandas as pd \nimport folium \nimport seaborn as sns \nimport matplotlib.pyplot as plt",
-    2: """# Статистический анализ числовых колонок
-    numeric_columns = df.select_dtypes(include='number').columns
-    for col in numeric_columns:
-        print(f"{col}:")
-        print(f"  Медиана: {df[col].median():.2f}")
-        print(f"  Среднее: {df[col].mean():.2f}")
-        print(f"  Стандартное отклонение: {df[col].std():.2f}")
-        print(f"  Асимметрия: {df[col].skew():.2f}")
-        print(f"  Эксцесс: {df[col].kurtosis():.2f}")
-        print(f"  Минимум: {df[col].min():.2f}")
-        print(f"  Максимум: {df[col].max():.2f}")
-        print()""",
-    3: """from statsmodels.graphics.gofplots import qqplot
-from matplotlib import pyplot
-qqplot(df.step_frequency, line='s')
-pyplot.show""",
-    4: """from scipy.stats import shapiro
-from scipy.stats import  normaltest
-shapiro(df.step_frequency)""",
-    5: """df['datetime'] = pd.to_datetime(df['datetime'])
-df['hour'] =df['datetime'].dt.hour
-df['time_of_day'] = pd.cut(df['hour'],bins = [0,6,12,18,24],labels=['Ночь','Утро','День','Вечер'],right=False)
+    1: """#### Задание:
+* Обучение модели - выборку проверить на дисбаланс, если необходимо устранить. Рассмотреть не менее 3 моделей классификации. Обучить выбранную модель, оценить ее качество.
+* Организовать непрерывное обучение 
+* Расссмотреть не менее 3 моделей регрессии, выбрать модель
+
+#### Результат модуля:
+* Выбрана модель классификации
+* 
+* Аналитическая записка с данными, графиками, выводами
+""",
+    2: """labels = cluster.labels_
+cluster_sizes = np.bincount(labels)
+print("Размеры кластеров:", cluster_sizes)
 """,
-    6: """plt.figure(figsize=(15,10))
-sns.heatmap(corr_matrix,annot=True)
-corr_matrix = dfcor.corr()""",
-    7: """lan = df['latitude'].mean()
-lon = df['longitude'].mean()
+    3: """from sklearn.metrics import  davies_bouldin_score
+dbi = davies_bouldin_score(X_scaled, labels)
+print("Индекс Дэвиса-Болдина:", dbi)""",
+    4: """df["Cluster"].value_counts()""",
+    5: """indices_to_drop = df[df['Cluster'] == 0].index[:10]
+df = df.drop(indices_to_drop)""",
+    6: """from sklearn.metrics import accuracy_score, mean_absolute_error, mean_squared_error, precision_score, recall_score, f1_score, confusion_matrix, r2_score
+from sklearn.metrics import classification_report
+from sklearn.metrics import confusion_matrix
+
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split""",
+    7: """X = df.drop(['Cluster','datetime','data','region'], axis=1)
+y = df['Cluster']""",
+    8: """X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)""",
+    9: """knn = KNeighborsClassifier()
+knn.fit(X_train, y_train)""",
+    10: """import joblib
+knn_clf = KNeighborsClassifier().fit(X_train, y_train)
+joblib.dump(knn_clf, 'classifier_model.pkl')  
+
+""",
+    11: """knn_predict = knn.predict(X_test)""",
+    12: """knn_train_predict = knn.predict(X_train)
+print('train accuracy: ', accuracy_score(y_train, knn_train_predict, normalize=True))
+print('test accuracy: ', accuracy_score(y_test, knn_predict, normalize=True))""",
+    13: """knn_accuracy = accuracy_score(y_test, knn_predict, normalize=True)""",
+    14: """print(classification_report(y_test, knn_predict))""",
+    15: """cm = confusion_matrix(y_test, knn_predict)
+
+sns.heatmap(cm, annot=True, fmt='d', cmap='Reds')
+plt.title('Confusion Matrix')
+plt.xlabel('Predicted Label')
+plt.ylabel('True Label')
+plt.show()""",
+    16: """from matplotlib.pylab import rc, plot
+from sklearn.metrics import roc_curve
+
+sns.set(font_scale=1)
+sns.set_color_codes("muted")
+
+plt.figure(figsize=(6, 4))
+fpr, tpr, thresholds = roc_curve(y_test, knn_predict, pos_label=1)
+lw = 2
+plt.plot(fpr, tpr, lw=lw, label='ROC curve ')
+plt.plot([0, 1], [0, 1])
+plt.xlim([0.0, 1.0])
+plt.ylim([0.0, 1.05])
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('ROC curve')
+plt.savefig("ROC.png")
+plt.show()""",
+    17: """gnb = GaussianNB()
+gnb.fit(X_train, y_train)""",
+    18: """svc = SVC()
+svc.fit(X_train, y_train)""",
+    19: """
+metrics_k = ['KNN accurancy', 'SVC accurancy','GNB accuracy']
+scores_k = [knn_accuracy, svc_accuracy,gnb_accuracy]
+
+plt.figure(figsize=(10, 6))
+plt.bar(metrics_k, scores_k, color=['blue', 'green'])
+plt.ylabel('Scores')
+plt.title('Comparison of Clustering Metrics')
+
+for i, v in enumerate(scores_k):
+    plt.text(i, v, f'{v:.4f}', ha='center', va='bottom')
+
+plt.show()""",
+    20: """import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+import warnings; warnings.filterwarnings('ignore')
+""",
+    21: """X = df.drop(['Cluster','datetime','data','region'], axis=1)
+y = df['step_frequency']
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+lr = LinearRegression()
+lr.fit(X_train_scaled, y_train)
+lr_pred = lr.predict(X_test_scaled)
+rf = RandomForestRegressor(n_estimators=100, random_state=42)
+rf.fit(X_train_scaled, y_train)
+rf_pred = rf.predict(X_test_scaled)
+gbr = GradientBoostingRegressor(n_estimators=100, random_state=42)
+gbr.fit(X_train_scaled, y_train)
+gbr_pred = gbr.predict(X_test_scaled)
+""",
+    22:"""def print_regression_report(y_true, y_pred, model_name):
+    mae = mean_absolute_error(y_true, y_pred)
+    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+    r2 = r2_score(y_true, y_pred)
+    print(f"{model_name}:\\n  MAE: {mae:.2f} шаг/мин | RMSE: {rmse:.2f} | R²: {r2:.3f}")
+
+print_regression_report(y_test, lr_pred, "LinearRegression")
+print_regression_report(y_test, rf_pred, "RandomForest")
+print_regression_report(y_test, gbr_pred, "GradientBoosting")""",
+    23:"""from fastapi import FastAPI, HTTPException
+import pandas as pd
+import joblib
+import numpy as np
+import warnings
+
+warnings.filterwarnings("ignore")""",
+    24:"""app = FastAPI()
+df = pd.read_csv('tracks.csv')
+model = joblib.load('classifier_model.pkl')
+n_features = model.n_features_in_""",
+    25:"""@app.get("/tracks")
+def get_tracks():
+    return {"track_ids": sorted(df['track_id'].astype(int).unique().tolist())}
+""",
+    26:"""@app.post("/predict/{track_id}")
+def predict_track(track_id: int):
+    track = df[df['track_id'] == track_id]
+    if len(track) == 0:
+        raise HTTPException(404, f"Track {track_id} not found")
+
+    cols = ['track_id', 'point_id'""",
+    27:"""   risks = []
+    for _, point in track.iterrows():
+        features = point[cols].fillna(0).values
+        if len(features) < n_features:
+            features = np.pad(features, (0, n_features - len(features)), 'constant')
+        risk = model.predict(features.reshape(1, -1))[0]
+        risks.append(int(risk))
+""",
+    28:"""  points_with_risk = track[['track_id', 'point_id', 'latitude', 'longitude',
+                              'elevation', 'temp', 'speed', 'step_frequency']].copy()
+    points_with_risk['risk'] = risks""",
+    29:""" points_json = []
+    for _, row in points_with_risk.iterrows():
+        points_json.append({
+            "track_id": int(row['track_id']),
+            "point_id": int(row['point_id']),
+            "latitude": float(row['latitude']),
+            "longitude": float(row['longitude']),
+            "elevation": float(row['elevation']),
+            "temp": float(row['temp']),
+            "speed": float(row['speed']),
+            "step_frequency": float(row['step_frequency']),
+            "risk": int(row['risk'])
+        })""",
+    30:""" return {
+        "track_id": int(track_id),
+        "total_points": int(len(points_json)),
+        "points": points_json
+    }""",
+    31:"""import streamlit as st
+import folium
+import pandas as pd
+import requests
+import numpy as np
+""",
+    32:"""@st.cache_data(ttl=300)
+def get_tracks():
+    try:
+        response = requests.get("http://127.0.0.1:8000/tracks")
+        return response.json()["track_ids"]
+    except:
+        st.error("")
+        return []""",
+    33:"""track_ids = get_tracks()
+selected_track = st.selectbox("Выбери трек:", track_ids)
+""",
+    34:"""if selected_track is not None and selected_track != "":
+    @st.cache_data(ttl=300)
+    def get_track_data(track_id):
+        try:
+            response = requests.post(f"http://127.0.0.1:8000/predict/{track_id}")
+            return response.json()
+        except:
+            st.error("Ошибка API!")
+            return None""",
+    35:"""track_data = get_track_data(selected_track)
+
+    if track_data and "points" in track_data:
+        points = pd.DataFrame(track_data["points"])
+
+        center_lat = points['latitude'].mean()
+        center_lon = points['longitude'].mean()
+
+        m = folium.Map(
+            location=[center_lat, center_lon],
+            zoom_start=14
+        )""",
+    36:"""avg_risk = points['risk'].mean()
+        line_color = 'green' if avg_risk < 1 else 'orange' if avg_risk < 1.5 else 'red'
 
-m = folium.Map(location=[lan,lon],zoom_start=18)
+        folium.PolyLine(
+            list(zip(points['latitude'], points['longitude'])),
+            color=line_color,
+            weight=4,
+            opacity=0.8,
+            popup=f"Трек {selected_track} (ср. риск: {avg_risk:.1f})"
+        ).add_to(m)""",
+    37:"""   for _, point in points.iterrows():
+            color = 'green' if point['risk'] == 0 else 'orange' if point['risk'] == 1 else 'red'
+            folium.CircleMarker(
+                location=[point['latitude'], point['longitude']],
+                radius=6,
+                color=color,
+                fill=True,
+                fillColor=color,
+                fillOpacity=0.7,
+                popup=f"Точка {point['point_id']}<br>"
+                      f"Риск: {point['risk']}<br>"
+                      f"Высота: {point['elevation']:.0f}м<br>"
+                      f"Скорость: {point['speed']:.1f}м/с"
+            ).add_to(m)""",
+    38:"""  legend_html = '''
+        <div style="position: fixed; bottom: 50px; right: 50px; width: 220px; height: auto; 
+        background-color: white; border:2px solid grey; z-index:9999; 
+        font-size:14px; padding: 12px; border-radius: 5px; box-shadow: 0 0 10px rgba(0,0,0,0.2);">
+        <p style="margin: 0 0 10px 0;"><b>Легенда рисков</b></p>
+        <p style="margin: 8px 0;">
+            <span style="color: green; font-size: 18px;">●</span> 
+            Низкий риск (0)
+        </p>
+        <p style="margin: 8px 0;">
+            <span style="color: orange; font-size: 18px;">●</span> 
+            Средний риск (1)
+        </p>
+        <p style="margin: 8px 0;">
+            <span style="color: red; font-size: 18px;">●</span> 
+            Высокий риск (2)
+        </p>
+        <p style="margin: 5px 0; font-size: 11px; color: #666;">
+            Линия: средний риск трека
+        </p>
+        </div>
+        '''""",
+    39:"""m.get_root().html.add_child(folium.Element(legend_html))
 
 
+        st.components.v1.html(m._repr_html_(), height=600)
+
 
-for idx,row in df.iterrows():
-    folium.CircleMarker(row[['latitude','longitude']].values,
-    color='red',radius = 3, fill = True ).add_to(m)
-m""",
-    8: """ if 'datetime' not in df.columns or df['datetime'].isnull().all():
-        df['datetime'] = pd.date_range('2026-01-01', periods=len(df), freq='1min')
     else:
-        df['datetime'] = pd.to_datetime(df['datetime'], errors='coerce').fillna(
-            pd.Timestamp('2026-01-01')
+        st.error("Трек не найден!")
+""",
+    40:"""import streamlit as st
+import folium
+import pandas as pd
+import requests
+import numpy as np
+
+st.title("Карта")
+
+
+@st.cache_data(ttl=300)
+def get_tracks():
+    try:
+        response = requests.get("http://127.0.0.1:8000/tracks")
+        return response.json()["track_ids"]
+    except:
+        st.error(" API недоступен! Запусти: python -m uvicorn api:app --reload")
+        return []
+
+
+track_ids = get_tracks()
+selected_track = st.selectbox("Выбери трек:", track_ids)
+
+if selected_track is not None and selected_track != "":
+    @st.cache_data(ttl=300)
+    def get_track_data(track_id):
+        try:
+            response = requests.post(f"http://127.0.0.1:8000/predict/{track_id}")
+            return response.json()
+        except:
+            st.error("Ошибка API!")
+            return None
+
+
+    track_data = get_track_data(selected_track)
+
+    if track_data and "points" in track_data:
+        points = pd.DataFrame(track_data["points"])
+
+        center_lat = points['latitude'].mean()
+        center_lon = points['longitude'].mean()
+
+        m = folium.Map(
+            location=[center_lat, center_lon],
+            zoom_start=14
         )
-           if 'latitude' not in df: df['latitude'] = 51.26 + np.random.normal(0, 0.01, len(df))
-    if 'longitude' not in df: df['longitude'] = 10.86 + np.random.normal(0, 0.01, len(df))
-    if 'speed' not in df: df['speed'] = np.random.normal(4, 1, len(df)).clip(1, 8)
-    
-    numeric = ['latitude', 'longitude', 'speed', 'elevation']
-    avail_num = [col for col in numeric if col in df.columns]
-     scaler = StandardScaler()
-    knn = KNNImputer(n_neighbors=5, weights='distance')
-    
-    df_num = df[avail_num].fillna(0)
-    df_scaled = scaler.fit_transform(df_num)
-    df_filled = knn.fit_transform(df_scaled)
-    df[avail_num] = scaler.inverse_transform(df_filled)
-      df['step_frequency'] = np.clip(df['speed'] / 3.6 / 0.75 * 60, 60, 140)
-        bins = [0, 500, 1500, 3000, float('inf')]
-    labels = ['лес', 'холмы', 'горы', 'альпы']
-    df['terrain_type'] = pd.cut(df['elevation'], bins=bins, labels=labels)
-        """,
-
-    9: """from sklearn import metrics
-from sklearn.cluster import AgglomerativeClustering
-from sklearn.cluster import KMeans
-from sklearn.cluster import SpectralClustering
-import scipy.cluster.hierarchy as shc
-from scipy.cluster.hierarchy import dendrogram, linkage
-from sklearn.metrics import silhouette_score
-from sklearn.metrics import calinski_harabasz_score
-from sklearn.decomposition import PCA""",
-    10: """
-X = df[['speed', 'elevation', 'step_frequency','temp']]
-from sklearn.preprocessing import StandardScaler
-scaler = StandardScaler()
-X_scaled=scaler.fit_transform(X)""",
-    11: """import plotly.express as px
-plt = px.scatter_3d(X, x='speed', y='elevation', z='step_frequency',
-                 title='K-Means')""",
-    12: """from sklearn.cluster import KMeans
-wcss=[]
-for k in range(1,11):
-    Kmeans = KMeans(n_clusters=k,random_state=42)
-    Kmeans.fit(X_scaled)
-    wcss.append(Kmeans.inertia_)
+
+        avg_risk = points['risk'].mean()
+        line_color = 'green' if avg_risk < 1 else 'orange' if avg_risk < 1.5 else 'red'
+
+        folium.PolyLine(
+            list(zip(points['latitude'], points['longitude'])),
+            color=line_color,
+            weight=4,
+            opacity=0.8,
+            popup=f"Трек {selected_track} (ср. риск: {avg_risk:.1f})"
+        ).add_to(m)
+
+        for _, point in points.iterrows():
+            color = 'green' if point['risk'] == 0 else 'orange' if point['risk'] == 1 else 'red'
+            folium.CircleMarker(
+                location=[point['latitude'], point['longitude']],
+                radius=6,
+                color=color,
+                fill=True,
+                fillColor=color,
+                fillOpacity=0.7,
+                popup=f"Точка {point['point_id']}<br>"
+                      f"Риск: {point['risk']}<br>"
+                      f"Высота: {point['elevation']:.0f}м<br>"
+                      f"Скорость: {point['speed']:.1f}м/с"
+            ).add_to(m)
+
+        legend_html = '''
+        <div style="position: fixed; bottom: 50px; right: 50px; width: 220px; height: auto; 
+        background-color: white; border:2px solid grey; z-index:9999; 
+        font-size:14px; padding: 12px; border-radius: 5px; box-shadow: 0 0 10px rgba(0,0,0,0.2);">
+        <p style="margin: 0 0 10px 0;"><b>Легенда рисков</b></p>
+        <p style="margin: 8px 0;">
+            <span style="color: green; font-size: 18px;">●</span> 
+            Низкий риск (0)
+        </p>
+        <p style="margin: 8px 0;">
+            <span style="color: orange; font-size: 18px;">●</span> 
+            Средний риск (1)
+        </p>
+        <p style="margin: 8px 0;">
+            <span style="color: red; font-size: 18px;">●</span> 
+            Высокий риск (2)
+        </p>
+        <p style="margin: 5px 0; font-size: 11px; color: #666;">
+            Линия: средний риск трека
+        </p>
+        </div>
+        '''
+        m.get_root().html.add_child(folium.Element(legend_html))
+
+
+        st.components.v1.html(m._repr_html_(), height=600)
+
+
+    else:
+        st.error("Трек не найден!")
+""",
+    41:"""@echo off
+echo Запуск API + Streamlit...
+start "FastAPI" cmd /k "cd /d C:PycharmProjects\MapPy && .venv\Scripts\activate && python -m uvicorn api:app --reload --port 8000"
+timeout /t 3
+start "Streamlit" cmd /k "cd /d C:PycharmProjects\MapPy && .venv\Scripts\activate && streamlit run app.py --server.port 8501"
+
+echo API: http://127.0.0.1:8000/docs
+echo Streamlit: http://127.0.0.1:8501
+pause
 """,
-    13: """sns.lineplot(x=range(1,11), y=wcss, marker='o')""",
-    14: """cluster = KMeans(n_clusters=3)
-kmeans = cluster.fit_predict(X_scaled)""",
-    15: """
-plt.figure(figsize=(20, 15), dpi=100)
-scatter=plt.scatter(X_scaled[:,0],X_scaled[:,1],c=kmeans)
-plt.legend(*scatter.legend_elements(), title="Кластеры")""",
-    16: """from sklearn.cluster import DBSCAN
-DbscanCluster = DBSCAN(eps=0.5, min_samples=20)
-dbscan = DbscanCluster.fit_predict(X_scaled)""",
-    17: """from sklearn.mixture import GaussianMixture
-gmm = GaussianMixture(n_components=2, random_state=0)
-gmm_pred = gmm.fit_predict(X_scaled)""",
-    18: """harabKmeans = metrics.calinski_harabasz_score(X_scaled, kmeans)
-metrics.calinski_harabasz_score(X_scaled, kmeans)""",
-    19: """silhKmeans = metrics.silhouette_score(X_scaled, kmeans)
-metrics.silhouette_score(X_scaled, kmeans)""",
-    20: """metrics = ['Kmeans', 'dbscan','gmm_pred']
-scores = [harabKmeans, harabDBscan,harabgmm_pred]
-plt.bar(metrics, scores, color=['blue', 'green'])
-for i, v in enumerate(scores):
-    plt.text(i, v, f'{v:.2f}', ha='center', va='bottom')""",
-    21: """GEOPOINT(FLOAT([Широта]), FLOAT([Долгота]))
-MARKUP(
-    "ID точки: ", [ID точки], BR(),
-    "Трек: ", [ID трека], BR(),
-    "Время: ", [Дататайм], BR(),
-    "Скорость: ", [Скорость], " км/ч", BR(),
-    "Температура: ", [Температура ], "°C"
-)""",
 }
 
 def s(id: int = 1) -> bool:

{sklip-0.5.0.dist-info → sklip-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sklip
-Version: 0.5.0
+Version: 0.6.0
 Author-email: Your Name <your@email.com>
 Project-URL: Homepage, https://github.com/yourusername/skclip
 Classifier: Programming Language :: Python :: 3

sklip-0.6.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+sklip/__init__.py,sha256=ykG5HRUgDu7PuujZfPCWupHhQs2AXSSCrAdTosS_Evc,122
+sklip/core.py,sha256=3ukn3v9xefUcscAK8OyiAplkbLU3XzDZ3EpCoCZcipI,15311
+sklip-0.6.0.dist-info/METADATA,sha256=Ol9z7cE1duGmGq56dGPDfCTiG-ImkslFgM-ruOUoPTU,404
+sklip-0.6.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sklip-0.6.0.dist-info/top_level.txt,sha256=V2T-257V83osKN3UDVUjuq-qK9nVZLF611GZPke9kiA,6
+sklip-0.6.0.dist-info/RECORD,,

sklip-0.5.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-sklip/__init__.py,sha256=4lWCB5E2PJUnWvnPFRNEC5cgnZCr8bqqkx1Gu8bGPb0,122
-sklip/core.py,sha256=ucuAt056w_G3AcoS4_LOO2OKF1HNHA-TB3ZsykTn52k,5858
-sklip-0.5.0.dist-info/METADATA,sha256=mxJriWi4c_mFaGBWKtOtLYiMtXt1hXRtG8yte57zy7A,404
-sklip-0.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-sklip-0.5.0.dist-info/top_level.txt,sha256=V2T-257V83osKN3UDVUjuq-qK9nVZLF611GZPke9kiA,6
-sklip-0.5.0.dist-info/RECORD,,