






"""simple docstring"""




# Logistic Regression from scratch

# In[62]:

# In[63]:

# importing all the required libraries

import numpy as np
from matplotlib import pyplot as plt
from sklearn import datasets

def 			lowerCAmelCase__     (     UpperCamelCase__				):



  '''simple docstring'''
  return 1 / (1 + np.exp(-z				))

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  return (-y * np.log(__lowerCAmelCase				) - (1 - y) * np.log(1 - h				)).mean()

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  _a  :       List[Any]             =	np.dot(__lowerCAmelCase     ,   __lowerCAmelCase				)
  return np.sum(y * scores - np.log(1 + np.exp(__lowerCAmelCase				)				)				)

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__=7_0_0_0_0				):



  '''simple docstring'''
  _a  :       Any             =	np.zeros(x.shape[1]				)

  for iterations in range(__lowerCAmelCase				):
    _a  :       Union[str, Any]             =	np.dot(__lowerCAmelCase     ,   __lowerCAmelCase				)
    _a  :       str             =	sigmoid_function(__lowerCAmelCase				)
    _a  :       List[str]             =	np.dot(x.T     ,   h - y				) / y.size
    _a  :       Tuple             =	theta - alpha * gradient  # updating the weights
    _a  :       Any             =	np.dot(__lowerCAmelCase     ,   __lowerCAmelCase				)
    _a  :       Dict             =	sigmoid_function(__lowerCAmelCase				)
    _a  :       Tuple             =	cost_function(__lowerCAmelCase     ,   __lowerCAmelCase				)
    if iterations % 1_0_0 == 0:
      print(F"""loss: {j} \t"""				)  # printing the loss after every 100 iterations
  return theta


# In[68]:

if __name__ == "__main__":
 _snake_case          =   datasets.load_iris()
 _snake_case          =   iris.data[:, :2]
 _snake_case          =   (iris.target != 0) * 1

 _snake_case          =   0.1
 _snake_case          =   logistic_reg(alpha, x, y, max_iterations=7_0000)
 print('theta: ', theta)  # printing the theta i.e our weights vector

 def 			lowerCAmelCase__     (     UpperCamelCase__				):



   '''simple docstring'''
   return sigmoid_function(
       np.dot(__lowerCAmelCase     ,   __lowerCAmelCase				)				)  # predicting the value of probability from the logistic regression algorithm

 plt.figure(figsize=(10, 6))
 plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color='b', label='0')
 plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color='r', label='1')
 ((_snake_case)      , (_snake_case))          =   (x[:, 0].min(), x[:, 0].max())
 ((_snake_case)      , (_snake_case))          =   (x[:, 1].min(), x[:, 1].max())
 ((_snake_case)      , (_snake_case))          =   np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
 _snake_case          =   np.c_[xxa.ravel(), xxa.ravel()]
 _snake_case          =   predict_prob(grid).reshape(xxa.shape)
 plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors='black')

 plt.legend()



 plt.show()






from unittest.mock import patch

import pyspark

from datasets.packaged_modules.spark.spark import (
    Spark,
    SparkExamplesIterable,
    _generate_iterable_examples,
)

from ..utils import (
    require_dill_gt_0_3_2,
    require_not_windows,
)



def 			_lowerCAmelCase       (					__lowerCAmelCase  ,  __lowerCAmelCase      )   ->					Tuple:


				"""simple docstring"""

				snake_case__	:      Union[str, Any]     		=	[]
				for part_id in partition_order:
								snake_case__	:      Any     		=	df.where(f"""SPARK_PARTITION_ID() = {part_id}"""      ).collect()
								for row_idx, row in enumerate(__lowerCAmelCase      ):
												expected_row_ids_and_row_dicts.append((f"""{part_id}_{row_idx}""", row.asDict())      )
				return expected_row_ids_and_row_dicts



@require_not_windows
@require_dill_gt_0_3_2
def 			_lowerCAmelCase       (					)   ->					Tuple:


				"""simple docstring"""

				snake_case__	:      Any     		=	pyspark.sql.SparkSession.builder.master('''local[*]'''      ).appName('''pyspark'''      ).getOrCreate()
				snake_case__	:      Optional[Any]     		=	spark.range(100      ).repartition(1      )
				snake_case__	:      Optional[int]     		=	Spark(__lowerCAmelCase      )
				# The id ints will be converted to Pyarrow int64s, so each row will be 8 bytes. Setting a max_shard_size of 16 means
				# that each partition can hold 2 rows.
				spark_builder._repartition_df_if_needed(max_shard_size=16      )
				# Given that the dataframe has 100 rows and each partition has 2 rows, we expect 50 partitions.
				assert spark_builder.df.rdd.getNumPartitions() == 50



@require_not_windows
@require_dill_gt_0_3_2
def 			_lowerCAmelCase       (					)   ->					Optional[int]:


				"""simple docstring"""

				snake_case__	:      Any     		=	pyspark.sql.SparkSession.builder.master('''local[*]'''      ).appName('''pyspark'''      ).getOrCreate()
				snake_case__	:      Dict     		=	spark.range(10      ).repartition(2      )
				snake_case__	:      Any     		=	[1, 0]
				snake_case__	:      Tuple     		=	_generate_iterable_examples(__lowerCAmelCase  ,  __lowerCAmelCase      )  # Reverse the partitions.
				snake_case__	:      Any     		=	_get_expected_row_ids_and_row_dicts_for_partition_order(__lowerCAmelCase  ,  __lowerCAmelCase      )

				for i, (row_id, row_dict) in enumerate(generate_fn()      ):
								snake_case__		, snake_case__	:      Union[str, Any]     		=	expected_row_ids_and_row_dicts[i]
								assert row_id == expected_row_id
								assert row_dict == expected_row_dict



@require_not_windows
@require_dill_gt_0_3_2
def 			_lowerCAmelCase       (					)   ->					Any:


				"""simple docstring"""

				snake_case__	:      Any     		=	pyspark.sql.SparkSession.builder.master('''local[*]'''      ).appName('''pyspark'''      ).getOrCreate()
				snake_case__	:      List[Any]     		=	spark.range(10      ).repartition(1      )
				snake_case__	:      int     		=	SparkExamplesIterable(__lowerCAmelCase      )
				assert it.n_shards == 1
				for i, (row_id, row_dict) in enumerate(__lowerCAmelCase      ):
								assert row_id == f"""0_{i}"""
								assert row_dict == {"id": i}



@require_not_windows
@require_dill_gt_0_3_2
def 			_lowerCAmelCase       (					)   ->					Dict:


				"""simple docstring"""

				snake_case__	:      List[str]     		=	pyspark.sql.SparkSession.builder.master('''local[*]'''      ).appName('''pyspark'''      ).getOrCreate()
				snake_case__	:      Tuple     		=	spark.range(30      ).repartition(3      )
				# Mock the generator so that shuffle reverses the partition indices.
				with patch('''numpy.random.Generator'''      ) as generator_mock:
								snake_case__	:      Union[str, Any]     		=	lambda __lowerCAmelCase      : x.reverse()
								snake_case__	:      List[str]     		=	_get_expected_row_ids_and_row_dicts_for_partition_order(__lowerCAmelCase  ,  [2, 1, 0]      )

								snake_case__	:      List[str]     		=	SparkExamplesIterable(__lowerCAmelCase      ).shuffle_data_sources(__lowerCAmelCase      )
								assert shuffled_it.n_shards == 3
								for i, (row_id, row_dict) in enumerate(__lowerCAmelCase      ):
												snake_case__		, snake_case__	:      Optional[Any]     		=	expected_row_ids_and_row_dicts[i]
												assert row_id == expected_row_id
												assert row_dict == expected_row_dict



@require_not_windows
@require_dill_gt_0_3_2
def 			_lowerCAmelCase       (					)   ->					List[Any]:


				"""simple docstring"""

				snake_case__	:      Union[str, Any]     		=	pyspark.sql.SparkSession.builder.master('''local[*]'''      ).appName('''pyspark'''      ).getOrCreate()
				snake_case__	:      Dict     		=	spark.range(20      ).repartition(4      )

				# Partitions 0 and 2
				snake_case__	:      List[Any]     		=	SparkExamplesIterable(__lowerCAmelCase      ).shard_data_sources(worker_id=0  ,  num_workers=2      )
				assert shard_it_a.n_shards == 2
				snake_case__	:      int     		=	_get_expected_row_ids_and_row_dicts_for_partition_order(__lowerCAmelCase  ,  [0, 2]      )
				for i, (row_id, row_dict) in enumerate(__lowerCAmelCase      ):
								snake_case__		, snake_case__	:      Dict     		=	expected_row_ids_and_row_dicts_a[i]
								assert row_id == expected_row_id
								assert row_dict == expected_row_dict

				# Partitions 1 and 3
				snake_case__	:      List[str]     		=	SparkExamplesIterable(__lowerCAmelCase      ).shard_data_sources(worker_id=1  ,  num_workers=2      )
				assert shard_it_a.n_shards == 2
				snake_case__	:      List[Any]     		=	_get_expected_row_ids_and_row_dicts_for_partition_order(__lowerCAmelCase  ,  [1, 3]      )
				for i, (row_id, row_dict) in enumerate(__lowerCAmelCase      ):
								snake_case__		, snake_case__	:      Optional[int]     		=	expected_row_ids_and_row_dicts_a[i]
								assert row_id == expected_row_id
								assert row_dict == expected_row_dict





@require_not_windows
@require_dill_gt_0_3_2
def 			_lowerCAmelCase       (					)   ->					Dict:


				"""simple docstring"""

				snake_case__	:      int     		=	pyspark.sql.SparkSession.builder.master('''local[*]'''      ).appName('''pyspark'''      ).getOrCreate()
				snake_case__	:      Dict     		=	spark.range(100      ).repartition(1      )
				snake_case__	:      Tuple     		=	Spark(__lowerCAmelCase      )
				# Choose a small max_shard_size for maximum partitioning.
				spark_builder._repartition_df_if_needed(max_shard_size=1      )
				# The new number of partitions should not be greater than the number of rows.
				assert spark_builder.df.rdd.getNumPartitions() == 100

