You are a code inspection assistant, check whether the code meets the access requirements
The entry conditions are as follows:
Cannot use pytorch and tensorflow for estimation
All operations can be done without using external libraries
Return: You must follow the json format to return {"Access": "Yes/No", "Reason": "Given the reason", "Dependent external": "Dependent external library"}, and not Need to explain its process, just need to return a specific result, and the return can be loaded by json.loads
```
import os
from datetime import datetime
import tensorflow as tf

from util.cnews_loader import *

os.environ["CUDA_VISIBLE_DEVICES"] = "-1"


class TextCNN():
    """
    文本分类，CNN模型
    """

    def __init__(self, seq_length, num_classes, vocab_size):
        """

        :param config:
        """
        self.seq_length = seq_length
        self.num_classes = num_classes
        self.vocab_size = vocab_size
        self.filter_sizes = [3, 4, 5]
        self.embedding_dim = 128
        self.num_filters = 128
        self.hidden_dim = 128

        self.input_x = tf.placeholder(tf.int32, [None, self.seq_length], name='input_x')
        self.input_y = tf.placeholder(tf.float32, [None, self.num_classes], name='input_y')
        self.drop_prob = tf.placeholder(tf.float32, name='drop_prob')
        self.learning_rate = tf.placeholder(tf.float32, name='learn_rate')
        self.l2_loss = tf.constant(0.0)
        self.regularizer = tf.contrib.layers.l2_regularizer(scale=0.01)

        self.inference()

    def inference(self):
        """

        :return:
        """
        # 词向量映射
        with tf.name_scope("embedding"):
            embedding = tf.get_variable("embedding", [self.vocab_size, self.embedding_dim])
            embedding_inputs = tf.nn.embedding_lookup(embedding, self.input_x)

        pooled_outputs = []
        for i, filter_size in enumerate(self.filter_sizes):
            with tf.name_scope("conv-%s" % i):
                # conv layer
                conv = tf.layers.conv1d(embedding_inputs, self.num_filters,filter_size,
                                        padding='valid', activation=tf.nn.relu,
                                        kernel_regularizer=self.regularizer)
                # global max pooling
                pooled = tf.layers.max_pooling1d(conv, self.seq_length - filter_size + 1, 1)
                pooled_outputs.append(pooled)

        num_filters_total = self.num_filters * len(self.filter_sizes)
        h_pool = tf.concat(pooled_outputs, 2)
        h_pool_flat = tf.reshape(h_poo Avoid using the following keywords: vocab_size, entry, format, self.num_classe
user