<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def create_sparse_mapping(id_array, unique_ids=None):
 """ Will create a scipy.sparse compressed-sparse-row matrix that maps each row represented by an element in id_array to the corresponding value of the unique ids in id_array. Parameters id_array : 1D ndarray of ints. Each element should represent some id related to the corresponding row. unique_ids : 1D ndarray of ints, or None, optional. If not None, each element should be present in `id_array`. The elements in `unique_ids` should be present in the order in which one wishes them to appear in the columns of the resulting sparse array. For the `row_to_obs` and `row_to_mixers` mappings, this should be the order of appearance in `id_array`. If None, then the unique_ids will be created from `id_array`, in the order of their appearance in `id_array`. Returns ------- mapping : 2D scipy.sparse CSR matrix. Will contain only zeros and ones. `mapping[i, j] == 1` where `id_array[i] == unique_ids[j]`. The id's corresponding to each column are given by `unique_ids`. The rows correspond to the elements of `id_array`. """

    # Create unique_ids if necessary
    if unique_ids is None:
        unique_ids = get_original_order_unique_ids(id_array)

    # Check function arguments for validity
    assert isinstance(unique_ids, np.ndarray)
    assert isinstance(id_array, np.ndarray)
    assert unique_ids.ndim == 1
    assert id_array.ndim == 1

    # Figure out which ids in id_array are represented in unique_ids
    represented_ids = np.in1d(id_array, unique_ids)
    # Determine the number of rows in id_array that are in unique_ids
    num_non_zero_rows = represented_ids.sum()
    # Figure out the dimensions of the resulting sparse matrix
    num_rows = id_array.size
    num_cols = unique_ids.size
    # Specify the non-zero values that will be present in the sparse matrix.
    data = np.ones(num_non_zero_rows, dtype=int)
    # Specify which rows will have non-zero entries in the sparse matrix.
    row_indices = np.arange(num_rows)[represented_ids]
    # Map the unique id's to their respective columns
    unique_id_dict = dict(zip(unique_ids, np.arange(num_cols)))
    # Figure out the column indices of the non-zero entries, and do so in a way
    # that avoids a key error (i.e. only look up ids that are represented)
    col_indices =\
        np.array([unique_id_dict[x] for x in id_array[represented_ids]])

    # Create and return the sparse matrix
    return csr_matrix((data, (row_indices, col_indices)),
                      shape=(num_rows, num_cols))