import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Load data
data = pd.read_csv('dataset.csv')

# Composition: Pie chart
plt.figure(figsize=(8, 6))
data['category_column'].value_counts().plot(kind='pie', autopct='%1.1f%%')
plt.title('Composition: Part-to-Whole Relationship')
plt.show()

# Distribution: Histogram
plt.figure(figsize=(8, 6))
sns.histplot(data['numerical_column'], kde=True)
plt.title('Distribution: Spread of Data Values')
plt.show()

# Relationship: Scatter plot
plt.figure(figsize=(8, 6))
sns.scatterplot(data=data, x='x_column', y='y_column')
plt.title('Relationship: Relationship between Variables')
plt.show()

# Comparison: Bar chart
plt.figure(figsize=(8, 6))
sns.barplot(data=data, x='category_column', y='numerical_column')
plt.title('Comparison: Comparison of Data Variables')
plt.show()

import pandas as pd
import numpy as np
import seaborn as sns
from scipy.stats import spearmanr, pearsonr, kendalltau
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.svm import SVR
from sklearn.tree import DecisionTreeRegressor
from sklearn.preprocessing import PolynomialFeatures
from sklearn.metrics import mean_squared_error

# Data Profiling

# Summary Functions
def summary_statistics(data):
    summary = data.describe()
    return summary

# Indexing
def index_data(data, column):
    indexed_data = data.set_index(column)
    return indexed_data

# Grouping
def group_data(data, column):
    grouped_data = data.groupby(column)
    return grouped_data

# Regression

# Linear Regression
def linear_regression(X, y):
    model = LinearRegression()
    model.fit(X, y)
    return model

# Multi Linear Regression
def multilinear_regression(X, y):
    model = LinearRegression()
    model.fit(X, y)
    return model

# Polynomial Regression
def polynomial_regression(X, y, degree):
    poly_features = PolynomialFeatures(degree=degree)
    X_poly = poly_features.fit_transform(X)
    model = LinearRegression()
    model.fit(X_poly, y)
    return model

# Support Vector Regression
def support_vector_regression(X, y):
    model = SVR()
    model.fit(X, y)
    return model

# Decision Tree Regression
def decision_tree_regression(X, y):
    model = DecisionTreeRegressor()
    model.fit(X, y)
    return model

# Random Forest Regression
def random_forest_regression(X, y):
    model = RandomForestRegressor()
    model.fit(X, y)
    return model

# Feature Engineering

# GroupBy Features
def groupby_features(data, group_column, agg_column):
    grouped_data = data.groupby(group_column)[agg_column].transform('mean')
    return grouped_data

# Categorical and Numerical Features
def identify_categorical_numerical_features(data):
    categorical_features = data.select_dtypes(include=['object', 'category']).columns.tolist()
    numerical_features = data.select_dtypes(include=['int', 'float']).columns.tolist()
    return categorical_features, numerical_features

# Missing Value Analysis

# Fill the missing Values
def fill_missing_values(data, method='mean'):
    if method == 'mean':
        filled_data = data.fillna(data.mean())
    elif method == 'median':
        filled_data = data.fillna(data.median())
    elif method == 'mode':
        filled_data = data.fillna(data.mode().iloc[0])
    else:
        filled_data = data.fillna(method=method)
    return filled_data

# Unique Value Analysis
def unique_value_analysis(data):
    unique_values = data.nunique()
    return unique_values

# Univariate Analysis
def univariate_analysis(data, column):
    sns.histplot(data[column])
    sns.boxplot(data[column])

# Bivariate Analysis
def bivariate_analysis(data, x_column, y_column):
    sns.scatterplot(data=data, x=x_column, y=y_column)
    sns.boxplot(data=data, x=x_column, y=y_column)

# Multivariate Analysis
def multivariate_analysis(data, columns):
    sns.pairplot(data[columns])

# Correlation Analysis

# Spearman's ρ
def spearman_correlation(data, x_column, y_column):
    correlation, _ = spearmanr(data[x_column], data[y_column])
    return correlation


# Pearson's r
def pearson_correlation(data, x_column, y_column):
    correlation, _ = pearsonr(data[x_column], data[y_column])
    return correlation

# Kendall's τ
def kendall_correlation(data, x_column, y_column):
    correlation, _ = kendalltau(data[x_column], data[y_column])
    return correlation

# Cramér's V (φc)
def cramers_v(data, x_column, y_column):
    confusion_matrix = pd.crosstab(data[x_column], data[y_column])
    chi2 = chi2_contingency(confusion_matrix)[0]
    n = np.sum(confusion_matrix)
    phi_c = np.sqrt(chi2 / (n * (min(confusion_matrix.shape) - 1)))
    return phi_c

# Phik (φk)
def phik(data, x_column, y_column):
    phik_matrix = phik_matrix(data[[x_column, y_column]])
    phik_value = phik_matrix.loc[x_column, y_column]
    return phik_value

# Example usage
data = pd.read_csv('dataset.csv')
correlation = pearson_correlation(data, 'column1', 'column2')
print('Pearson correlation:', correlation)

kendall_corr = kendall_correlation(data, 'column1', 'column2')
print('Kendall correlation:', kendall_corr)

cramers_v_value = cramers_v(data, 'column1', 'column2')
print("Cramér's V:", cramers_v_value)

phik_value = phik(data, 'column1', 'column2')
print('Phik:', phik_value)

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
from bokeh.plotting import figure, show
from bokeh.io import output_notebook

# Data Visualization - Part 2: Matplotlib and Seaborn

# Basic Functions

# Line plot
def line_plot(x, y, title):
    plt.plot(x, y)
    plt.title(title)
    plt.xlabel('X-axis')
    plt.ylabel('Y-axis')
    plt.show()

# Bar plot
def bar_plot(x, y, title):
    plt.bar(x, y)
    plt.title(title)
    plt.xlabel('X-axis')
    plt.ylabel('Y-axis')
    plt.show()

# Scatter plot
def scatter_plot(x, y, title):
    plt.scatter(x, y)
    plt.title(title)
    plt.xlabel('X-axis')
    plt.ylabel('Y-axis')
    plt.show()

# Advanced Functions

# Heatmap
def heatmap(data, title):
    sns.heatmap(data)
    plt.title(title)
    plt.show()

# Pairplot
def pairplot(data):
    sns.pairplot(data)
    plt.show()

# Data Visualization - Part 3: Plotly

# Line plot with Plotly
def plotly_line_plot(data, x, y, title):
    fig = px.line(data, x=x, y=y, title=title)
    fig.show()

# Scatter plot with Plotly
def plotly_scatter_plot(data, x, y, color, title):
    fig = px.scatter(data, x=x, y=y, color=color, title=title)
    fig.show()

# Data Visualization using Bokeh

# Line plot with Bokeh
def bokeh_line_plot(data, x, y, title):
    output_notebook()
    p = figure(title=title, x_axis_label='X-axis', y_axis_label='Y-axis')
    p.line(data[x], data[y])
    show(p)

# Scatter plot with Bokeh
def bokeh_scatter_plot(data, x, y, title):
    output_notebook()
    p = figure(title=title, x_axis_label='X-axis', y_axis_label='Y-axis')
    p.circle(data[x], data[y])
    show(p)

# Example usage

# Load data
data = pd.read_csv('dataset.csv')

# Line plot
line_plot(data['x'], data['y'], 'Line Plot')

# Bar plot
bar_plot(data['category'], data['count'], 'Bar Plot')

# Scatter plot
scatter_plot(data['x'], data['y'], 'Scatter Plot')

# Heatmap
heatmap(data.corr(), 'Correlation Heatmap')

# Pairplot
pairplot(data)

# Plotly line plot
plotly_line_plot(data, 'x', 'y', 'Line Plot (Plotly)')

# Plotly scatter plot
plotly_scatter_plot(data, 'x', 'y', 'category', 'Scatter Plot (Plotly)')

# Bokeh line plot
bokeh_line_plot(data, 'x', 'y', 'Line Plot (Bokeh)')

# Bokeh scatter plot
bokeh_scatter_plot(data, 'x', 'y', 'Scatter Plot (Bokeh)')