keras accuracy doesn't improve more than 59 percent

It seems to me that for a neural network your data is not variate enough. You have a lot of similar values in your dataset. That might be a reason of the low accuracy. Try a simple regressor and not a neural network.

If you want to use a neural network at any rate, you should change the followings:

Generally for regression you should set the activation function for your last layer to 'relu' or 'linear', sigmoid is usually used for the hiden layers.

Try to change these first. If it does not work, try also different strategies as :

1. Increase the batch size
2. Increase the number of epochs
3. Apply whitening to your dataset before running (pre-processing stage).
4. Decrease the learning rate, you should use scheduler.

For whitening you can do:

from sklearn.decomposition import PCA

pca = PCA(whiten=True)
pca.fit(X)
X = pca.transform(X)

# make here train test split ...

X_test = pca.transform(X_test) # use the same pca model for the test set.

You have a lot of zeros in your dataset. Here you have a list of percentage of zero values per column (between 0 and 1):

0.6611697598907094 WORK_EDUCATION
0.5906196483663051 SHOP
0.15968546556987515 OTHER
0.4517919980835284 AM
0.3695455825652879 PM
0.449195697003247 MIDDAY
0.8160996565242585 NIGHT
0.03156998520561604 AVG_VEH_CNT
1.618641571247746e-05 work_traveltime
2.2660981997468445e-05 shop_traveltime
0.6930343378622924 work_tripmile
0.605410795044367 shop_tripmile
0.185622578107549 TRPMILES_sum
3.237283142495492e-06 TRVL_MIN_sum
0.185622578107549 TRPMILES_mean
0.469645614614391 HBO
0.5744850291841075 HBSHOP
0.8137429143965219 HBW
0.5307266729469959 NHB
0.2017960446874565 DWELTIME_mean
1.618641571247746e-05 TRVL_MIN_mean
0.6959996892208183 work_dweltime
0.6099365168775757 shop_dweltime
0.0009258629787537107 firsttrip_time
0.002949164942813393 lasttrip_time
0.7442934791405661 age_2.0
0.7541995655566023 age_3.0
0.7081200773063214 age_4.0
0.9401296855626884 age_5.0
0.3490503429901489 KNN_result

In short: NNs are rarely the best models for classifying either small amounts data or the data that is already compactly represented by a few non-heterogeneous columns. Often enough, boosted methods or GLM would produce better results from a similar amount of effort.

What can you do with your model? Counterintuitively, sometimes hindering the network capacity can be beneficial, especially when the number of network parameters exceeds number of training points. One can reduce the number of neurons, like in your case setting layer sizes to 16 or so and simultaneously removing layers; introduce regularizations (label smoothing, weight decay, etc); or generate more data by adding more derived columns in different (log, binary) scales.

Another approach would be to search for NNs models designed for your type of data. As, for example, Self-Normalizing Neural Networks or Wide & Deep Learning for Recommender Systems.

If you get to try only 1 thing, I would recommend doing a grid search of the learning rate or trying a few different optimizers.

How to make a better decision about which model to use? Look through finished kaggle.com competitions and find datasets similar to the one at hand, then check out the techniques used by the top places.

Decrease batch size and transform dependent variable (Y) with pd.get_dummies

In the last layer use:

model.add(Dense(2, activation='sigmoid'))

Also, depending upon the size of your data, you can decrease the number of neurons to 128 from 256.

Decrease Dropout to 0.2:

model = Sequential()
model.add(Dense(128, input_shape=(X_train.shape[1],), activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(layers.Dropout(0.2))
model.add(Dense(128, activation='relu'))
model.add(layers.Dropout(0.2))
model.add(Dense(2, activation='sigmoid'))

OK, I tested another algorithm, Catboost, and I got accuracy : 0.9295405324035856

Here :

Imports, constants and function :

from catboost import CatBoostRegressor, Pool

PARAMS_CATBOOST_REGRESSOR = dict()
PARAMS_CATBOOST_REGRESSOR['learning_rate']=0.1
PARAMS_CATBOOST_REGRESSOR['use_best_model']= True
PARAMS_CATBOOST_REGRESSOR['logging_level'] = 'Silent'
PARAMS_CATBOOST_REGRESSOR['l2_leaf_reg'] = 1.0 # lambda, default 3, S: 300

SPLITS=5

def get_prediction(X, Y, X_predict):
    kf = KFold(n_splits=SPLITS, shuffle=True)
    
    count=0
    cat_features=[]
    y_test_predict = np.zeros((X_predict.shape[0]))
    oo = np.zeros((X.shape[0]))  
    
    clf = CatBoostRegressor(**PARAMS_CATBOOST_REGRESSOR)
        
    for train_index, test_index in kf.split(X, Y):
           count = count+1
           print("Split "+str(count)+" ... ")

           X_train, X_test = X.iloc[train_index], X.iloc[test_index]
           y_train, y_test = Y.iloc[train_index], Y.iloc[test_index]

           train_dataset = Pool(data=X_train,
                     label=y_train,
                     cat_features=cat_features)

           eval_dataset = Pool(data=X_test,
                     label=y_test,
                     cat_features=cat_features)

           clf.fit(train_dataset,
                    use_best_model=True,
                    eval_set=eval_dataset)

           print("Count of trees in model = {}".format(clf.tree_count_))
            
           oo[test_index] = clf.predict(X_test)
           y_test_predict += clf.predict(X_predict)    
            
    y_test_predict = y_test_predict/float(SPLITS)
    return (oo, y_test_predict)

Pre Processing :

df = pd.read_csv('df1.csv')
y = df['R_SEX'].values

# Add a column with number of zeros per row
df['c_zero'] = (df == 0).astype(int).sum(axis=1) 

# Delete columns with more than 70% zeros
l1 = ['R_SEX', 'NIGHT', 'age_2.0', 'age_3.0', 'age_4.0','age_5.0', 'HBW', 'work_tripmile',  'work_dweltime', 'WORK_EDUCATION' ]
x_cols = [c for c in df.columns if c not in l1]

X = df[x_cols].values
sh = df.shape[0]

# Normalize : 
for c in df[x_cols]:
  dd = df.loc[df[c]==0]
  print(dd.shape[0]/df.shape[0], c)

Run :

df.reset_index(drop=True, inplace=True)
YY = df['R_SEX']
XX = df[x_cols]
(oo, ypred) = get_prediction(XX, YY, XX)

Parse score :

df = pd.DataFrame(oo, columns=['pred'])
df['y'] = YY
df['v'] = df.apply(lambda row: 1 if row['pred']>=0.5 else 0, axis=1)
df.sort_values(by=['y'])
df['diff'] = df['v'] - df['y']
pp = df[df['diff']==0].shape[0]
pdf = df.shape[0]
    
print(pp/pdf)

Result :

Score = 0.9295405324035856