javascript

java

python

c#

android

node.js

reactjs

c++

php

html

jquery

css

git

.net

ios

ruby-on-rails

sql

c

string

ruby

人工智能-输入数量可变时如何使用神经网络?

我所看到的神经网络的所有示例都是针对一组固定的输入,这些输入对于图像和固定长度的数据非常有效。 您如何处理长度可变的数据,例如句子,查询或源代码? 有没有一种方法可以将可变长度的数据编码为固定长度的输入,并且仍然获得神经网络的泛化特性?

trans by 2019-11-11T18:53:22Z

使用python和numpy进行梯度下降

def gradient(X_norm,y,theta,alpha,m,n,num_it):
    temp=np.array(np.zeros_like(theta,float))
    for i in range(0,num_it):
        h=np.dot(X_norm,theta)
        #temp[j]=theta[j]-(alpha/m)*(  np.sum( (h-y)*X_norm[:,j][np.newaxis,:] )  )
        temp[0]=theta[0]-(alpha/m)*(np.sum(h-y))
        temp[1]=theta[1]-(alpha/m)*(np.sum((h-y)*X_norm[:,1]))
        theta=temp
    return theta



X_norm,mean,std=featureScale(X)
#length of X (number of rows)
m=len(X)
X_norm=np.array([np.ones(m),X_norm])
n,m=np.shape(X_norm)
num_it=1500
alpha=0.01
theta=np.zeros(n,float)[:,np.newaxis]
X_norm=X_norm.transpose()
theta=gradient(X_norm,y,theta,alpha,m,n,num_it)
print theta

我上面的代码中的theta是100.2 100.2,但是在matlab中应该是100.2 61.09

trans by 2019-11-10T13:53:40Z

java-Porter和Lancaster提取算法的主要区别和好处是什么?

我正在处理Java中的文档分类任务。

强烈推荐这两种算法,每种算法都有什么优点和缺点,并且在自然语言处理任务的文献中更常用?

trans by 2019-11-08T14:20:50Z

机器学习-时间序列中的模式识别

通过处理时间序列图,我想检测类似于以下内容的模式:

enter image description here

以示例时间序列为例,我希望能够检测到此处标记的模式:

enter image description here

我需要使用哪种AI算法(我假设是机器学习技术)? 我可以使用任何库(C / C ++)吗?

trans by 2019-11-07T16:49:16Z

python-使用sklearn在PCA中恢复featured_variance_ratio_的特征名称

我正在尝试从使用scikit-learn完成的PCA中恢复,这些功能被选择为相关功能。

IRIS数据集的经典示例。

import pandas as pd
import pylab as pl
from sklearn import datasets
from sklearn.decomposition import PCA

# load dataset
iris = datasets.load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)

# normalize data
df_norm = (df - df.mean()) / df.std()

# PCA
pca = PCA(n_components=2)
pca.fit_transform(df_norm.values)
print pca.explained_variance_ratio_

这返回

In [42]: pca.explained_variance_ratio_
Out[42]: array([ 0.72770452,  0.23030523])

如何恢复数据集中哪两个特征允许这两个已解释的方差?换句话说,我如何在iris.feature_names中获取此功能的索引?

In [47]: print iris.feature_names
['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

在此先感谢您的帮助。

trans by 2019-11-03T00:36:32Z

理解Scikit CountVectoriz中的min_df和max_df

我有五个输入到CountVectorizer的文本文件。 当为CountVectorizer实例指定min_df和max_df时,最小/最大文档频率到底是什么意思? 是某个单词在其特定文本文件中的出现频率,还是整个整体语料库(5个txt文件)中该单词的出现频率?

当min_df和max_df作为整数或浮点数提供时有何不同?

该文档似乎没有提供详尽的解释,也没有提供示例来演示min_df和/或max_df的用法。 有人可以提供说明min_df或max_df的解释或示例。

trans by 2019-10-25T14:22:19Z

c-感知器学习算法未收敛到0

这是我在ANSI C中的感知器实现:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

float randomFloat()
{
    srand(time(NULL));
    float r = (float)rand() / (float)RAND_MAX;
    return r;
}

int calculateOutput(float weights[], float x, float y)
{
    float sum = x * weights[0] + y * weights[1];
    return (sum >= 0) ? 1 : -1;
}

int main(int argc, char *argv[])
{
    // X, Y coordinates of the training set.
    float x[208], y[208];

    // Training set outputs.
    int outputs[208];

    int i = 0; // iterator

    FILE *fp;

    if ((fp = fopen("test1.txt", "r")) == NULL)
    {
        printf("Cannot open file.\n");
    }
    else
    {
        while (fscanf(fp, "%f %f %d", &x[i], &y[i], &outputs[i]) != EOF)
        {
            if (outputs[i] == 0)
            {
                outputs[i] = -1;
            }
            printf("%f   %f   %d\n", x[i], y[i], outputs[i]);
            i++;
        }
    }

    system("PAUSE");

    int patternCount = sizeof(x) / sizeof(int);

    float weights[2];
    weights[0] = randomFloat();
    weights[1] = randomFloat();

    float learningRate = 0.1;

    int iteration = 0;
    float globalError;

    do {
        globalError = 0;
        int p = 0; // iterator
        for (p = 0; p < patternCount; p++)
        {
            // Calculate output.
            int output = calculateOutput(weights, x[p], y[p]);

            // Calculate error.
            float localError = outputs[p] - output;

            if (localError != 0)
            {
                // Update weights.
                for (i = 0; i < 2; i++)
                {
                    float add = learningRate * localError;
                    if (i == 0)
                    {
                        add *= x[p];
                    }
                    else if (i == 1)
                    {
                        add *= y[p];
                    }
                    weights[i] +=  add;
                }
            }

            // Convert error to absolute value.
            globalError += fabs(localError);

            printf("Iteration %d Error %.2f %.2f\n", iteration, globalError, localError);

            iteration++;
        }

        system("PAUSE");

    } while (globalError != 0);

    system("PAUSE");
    return 0;
}

我正在使用的训练集:数据集

我删除了所有不相关的代码。 基本上现在执行的操作是读取globalError文件,并将文件中的值加载到三个数组中:xyoutputs

然后是一个感知器学习算法,由于某种原因,该算法没有收敛到0(globalError应该收敛到0),因此我得到了一个无限的do while循环。

当我使用较小的训练集(如5分)时,效果很好。 有什么想法可能是问题所在吗?

我编写的算法与此C#Perceptron算法非常相似:


编辑:

这是带有较小训练集的示例:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

float randomFloat()
{
    float r = (float)rand() / (float)RAND_MAX;
    return r;
}

int calculateOutput(float weights[], float x, float y)
{
    float sum = x * weights[0] + y * weights[1];
    return (sum >= 0) ? 1 : -1;
}

int main(int argc, char *argv[])
{
    srand(time(NULL));

    // X coordinates of the training set.
    float x[] = { -3.2, 1.1, 2.7, -1 };

    // Y coordinates of the training set.
    float y[] = { 1.5, 3.3, 5.12, 2.1 };

    // The training set outputs.
    int outputs[] = { 1, -1, -1, 1 };

    int i = 0; // iterator

    FILE *fp;

    system("PAUSE");

    int patternCount = sizeof(x) / sizeof(int);

    float weights[2];
    weights[0] = randomFloat();
    weights[1] = randomFloat();

    float learningRate = 0.1;

    int iteration = 0;
    float globalError;

    do {
        globalError = 0;
        int p = 0; // iterator
        for (p = 0; p < patternCount; p++)
        {
            // Calculate output.
            int output = calculateOutput(weights, x[p], y[p]);

            // Calculate error.
            float localError = outputs[p] - output;

            if (localError != 0)
            {
                // Update weights.
                for (i = 0; i < 2; i++)
                {
                    float add = learningRate * localError;
                    if (i == 0)
                    {
                        add *= x[p];
                    }
                    else if (i == 1)
                    {
                        add *= y[p];
                    }
                    weights[i] +=  add;
                }
            }

            // Convert error to absolute value.
            globalError += fabs(localError);

            printf("Iteration %d Error %.2f\n", iteration, globalError);          
        }

        iteration++;

    } while (globalError != 0);

    // Display network generalisation.
    printf("X       Y     Output\n");
    float j, k;
    for (j = -1; j <= 1; j += .5)
    {
        for (j = -1; j <= 1; j += .5)
        {
            // Calculate output.
            int output = calculateOutput(weights, j, k);
            printf("%.2f  %.2f  %s\n", j, k, (output == 1) ? "Blue" : "Red");
        }
    }

    // Display modified weights.
    printf("Modified weights: %.2f %.2f\n", weights[0], weights[1]);

    system("PAUSE");
    return 0;
}
trans by 2019-10-13T09:06:42Z

机器学习-TensorFlow-具有L2损失的正则化,如何应用于所有权重,而不仅仅是最后一个?

我正在玩AN,它是Udacity深度学习课程的一部分。

我的一项作业涉及使用L2损耗将通用性引入具有一个隐藏ReLU层的网络。 我想知道如何正确地引入它,以便所有权重都受到惩罚,而不仅仅是输出层的权重。

无需底部概括的网络代码位于帖子的底部(实际运行培训的代码不在问题范围内)。

引入L2的一种明显方法是将损失计算替换为以下内容(如果beta为0.01):

loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(out_layer, tf_train_labels) + 0.01*tf.nn.l2_loss(out_weights))

但是在这种情况下,它将考虑输出层权重的值。 我不确定,我们如何适当地惩罚进入隐藏的ReLU层的权重。 是根本需要还是对输出层进行惩罚会以某种方式控制隐藏的权重?

#some importing
from __future__ import print_function
import numpy as np
import tensorflow as tf
from six.moves import cPickle as pickle
from six.moves import range

#loading data
pickle_file = '/home/maxkhk/Documents/Udacity/DeepLearningCourse/SourceCode/tensorflow/examples/udacity/notMNIST.pickle'

with open(pickle_file, 'rb') as f:
  save = pickle.load(f)
  train_dataset = save['train_dataset']
  train_labels = save['train_labels']
  valid_dataset = save['valid_dataset']
  valid_labels = save['valid_labels']
  test_dataset = save['test_dataset']
  test_labels = save['test_labels']
  del save  # hint to help gc free up memory
  print('Training set', train_dataset.shape, train_labels.shape)
  print('Validation set', valid_dataset.shape, valid_labels.shape)
  print('Test set', test_dataset.shape, test_labels.shape)


#prepare data to have right format for tensorflow
#i.e. data is flat matrix, labels are onehot

image_size = 28
num_labels = 10

def reformat(dataset, labels):
  dataset = dataset.reshape((-1, image_size * image_size)).astype(np.float32)
  # Map 0 to [1.0, 0.0, 0.0 ...], 1 to [0.0, 1.0, 0.0 ...]
  labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32)
  return dataset, labels
train_dataset, train_labels = reformat(train_dataset, train_labels)
valid_dataset, valid_labels = reformat(valid_dataset, valid_labels)
test_dataset, test_labels = reformat(test_dataset, test_labels)
print('Training set', train_dataset.shape, train_labels.shape)
print('Validation set', valid_dataset.shape, valid_labels.shape)
print('Test set', test_dataset.shape, test_labels.shape)


#now is the interesting part - we are building a network with
#one hidden ReLU layer and out usual output linear layer

#we are going to use SGD so here is our size of batch
batch_size = 128

#building tensorflow graph
graph = tf.Graph()
with graph.as_default():
      # Input data. For the training data, we use a placeholder that will be fed
  # at run time with a training minibatch.
  tf_train_dataset = tf.placeholder(tf.float32,
                                    shape=(batch_size, image_size * image_size))
  tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
  tf_valid_dataset = tf.constant(valid_dataset)
  tf_test_dataset = tf.constant(test_dataset)

  #now let's build our new hidden layer
  #that's how many hidden neurons we want
  num_hidden_neurons = 1024
  #its weights
  hidden_weights = tf.Variable(
    tf.truncated_normal([image_size * image_size, num_hidden_neurons]))
  hidden_biases = tf.Variable(tf.zeros([num_hidden_neurons]))

  #now the layer itself. It multiplies data by weights, adds biases
  #and takes ReLU over result
  hidden_layer = tf.nn.relu(tf.matmul(tf_train_dataset, hidden_weights) + hidden_biases)

  #time to go for output linear layer
  #out weights connect hidden neurons to output labels
  #biases are added to output labels  
  out_weights = tf.Variable(
    tf.truncated_normal([num_hidden_neurons, num_labels]))  

  out_biases = tf.Variable(tf.zeros([num_labels]))  

  #compute output  
  out_layer = tf.matmul(hidden_layer,out_weights) + out_biases
  #our real output is a softmax of prior result
  #and we also compute its cross-entropy to get our loss
  loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(out_layer, tf_train_labels))

  #now we just minimize this loss to actually train the network
  optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)

  #nice, now let's calculate the predictions on each dataset for evaluating the
  #performance so far
  # Predictions for the training, validation, and test data.
  train_prediction = tf.nn.softmax(out_layer)
  valid_relu = tf.nn.relu(  tf.matmul(tf_valid_dataset, hidden_weights) + hidden_biases)
  valid_prediction = tf.nn.softmax( tf.matmul(valid_relu, out_weights) + out_biases) 

  test_relu = tf.nn.relu( tf.matmul( tf_test_dataset, hidden_weights) + hidden_biases)
  test_prediction = tf.nn.softmax(tf.matmul(test_relu, out_weights) + out_biases)
trans by 2019-10-09T12:47:23Z

机器学习-支持向量的数量与训练数据和分类器性能之间的关系是什么?

我正在使用LibSVM对一些文档进行分类。 正如最终结果所示,这些文档似乎很难归类。 但是,在训练模型时,我注意到了一些东西。 就是说:如果我的训练集例如是1000,则其中约800个被选为支持向量。我到处寻找,发现这是好事还是坏事。 我的意思是支持向量的数量和分类器的性能之间有关系吗?我已经阅读了该帖子的上一篇文章。 但是,我正在执行参数选择,并且我还要确保特征向量中的属性都是有序的。我只需要知道这种关系。谢谢。ps:我使用线性核。

trans by 2019-10-04T19:24:17Z

如何根据损失值告诉Keras停止训练?

目前,我使用以下代码:

callbacks = [
    EarlyStopping(monitor='val_loss', patience=2, verbose=0),
    ModelCheckpoint(kfold_weights_path, monitor='val_loss', save_best_only=True, verbose=0),
]
model.fit(X_train.astype('float32'), Y_train, batch_size=batch_size, nb_epoch=nb_epoch,
      shuffle=True, verbose=1, validation_data=(X_valid, Y_valid),
      callbacks=callbacks)

它告诉Keras,如果损失在2个时期内没有改善,就停止训练。 但是我要在损失变得小于某个恒定的“ THR”后停止训练:

if val_loss < THR:
    break

我在文档中看到有可能进行自己的回调:[http://keras.io/callbacks/]但是没有发现如何停止训练过程。 我需要个建议。

trans by 2019-10-03T09:35:52Z

机器学习-训练期间出现Nans的常见原因

我注意到在培训期间经常发生的2255563852739347456s被引入。

通常,它似乎是通过权重引入内部产品/完全连接的或卷积层中的。

这是因为梯度计算正在爆炸吗? 还是因为权重初始化(如果是这样,为什么权重初始化会产生这种效果)? 还是可能是由于输入数据的性质引起的?

这里的首要问题很简单:在训练过程中发生NAN的最常见原因是什么? 其次,有什么方法可以解决这个问题(为什么它们起作用)?

trans by 2019-10-03T05:59:51Z

机器学习-如何提高朴素贝叶斯分类器的准确性?

我正在使用朴素贝叶斯分类器将数千个文档分类为30个不同的类别。 我已经实现了朴素贝叶斯分类器,并且通过一些功能选择(主要是过滤无用的单词),我获得了大约30%的测试准确度和45%的训练准确度。 这比随机的要好得多,但是我希望它能更好。

我已经尝试过用NB实现AdaBoost,但是它似乎并没有给出明显更好的结果(关于这方面的文献似乎有些分歧,有些论文说,使用NB的AdaBoost不会给出更好的结果,而另一些则表明)。 您是否知道NB的其他扩展可能会带来更好的准确性?

trans by 2019-10-02T12:37:10Z

机器学习-Keras中的多对一和多对多LSTM示例

我试图了解LSTM以及如何使用Keras构建它们。 我发现,主要有4种模式可以运行RNN(图中的4种正确模式)

enter image description here图片来源:Andrej Karpathy

现在,我想知道在Keras中,每个代码的简约代码段看起来如何。所以像

model = Sequential()
model.add(LSTM(128, input_shape=(timesteps, data_dim)))
model.add(Dense(1))

对于这4个任务中的每一个,也许都需要一点解释。

trans by 2019-09-30T17:49:17Z

熊猫-如何在Python中进行热编码?

我有一个80%分类变量的机器学习分类问题。 如果要使用一些分类器进行分类,是否必须使用一种热编码? 我可以在没有编码的情况下将数据传递给分类器吗?

我正在尝试进行以下功能选择:

  1. 我读了火车文件:

    train_small_with_dummies = pd.get_dummies(train_small, sparse=True)
    
  2. 我将类别特征的类型更改为“类别”:

    train_small_with_dummies = pd.get_dummies(train_small, sparse=True)
    
  3. 我使用一种热编码:

    train_small_with_dummies = pd.get_dummies(train_small, sparse=True)
    

问题是,尽管我使用的是坚固的机器,但第3部分经常卡住。

因此,如果没有一种热编码,我将无法进行任何特征选择来确定特征的重要性。

您有什么推荐的吗?

trans by 2019-09-28T21:53:22Z

可以-Tensorflow后端的Keras可以被迫随意使用CPU或GPU吗?

我安装了Tensorflow后端和CUDA的Keras。 我有时想按需强迫Keras使用CPU。 不用说在虚拟环境中安装单独的仅CPU的Tensorflow就能做到吗? 如果可以,怎么办? 如果后端是Theano,则可以设置标志,但是我还没有听说过可以通过Keras访问Tensorflow标志。

trans by 2019-09-27T23:07:50Z

机器学习-估计人工神经元的神经元数量和层数

我正在寻找一种有关如何计算层数和每层神经元数的方法。 作为输入,我仅具有输入向量的大小,输出向量的大小和训练集的大小。

通常,最好的网络是通过尝试不同的网络拓扑并选择误差最小的网络来确定的。 不幸的是我做不到。

trans by 2019-09-23T18:59:09Z

机器学习-目标检测和计算机视觉中的mAP度量

在计算机视觉和目标检测中,常用的评估方法是mAP。它是什么以及如何计算?

trans by 2019-09-22T09:53:26Z

定义 - 什么是机器学习?

  • 什么是机器学习?
  • 机器学习代码有什么作用?
  • 当我们说机器学习时,它是修改自己的代码还是修改历史(数据库),它将包含给定输入集的代码体验?
trans by 2019-09-16T14:19:23Z

是否有推荐的Python机器学习包?

是否有推荐的Python机器学习包?

我以前在C ++和MATLAB中实现各种机器学习和统计算法的经验,但在Python中做了一些工作我很好奇Python的可用包。

trans by 2019-09-13T23:04:31Z

机器学习 - 多层感知器(MLP)架构:选择隐藏层数和隐藏层大小的标准?

如果我们有10个特征向量,那么我们可以在输入层有10个神经节点。如果我们有5个输出类,那么我们可以在输出层有5个节点。但是选择MLP中隐藏层数的标准是什么? 1个隐藏层中的节点?

trans by 2019-08-07T02:01:52Z

1 2 3 4 5 6 下一页 共6页